Para capturar datos te recomiendo el post que publique:

https://foro.elhacker.net/programacion_cc/plantillas_programas_escolares_en_c-t489889.0.html

Ahi podrar captirar N cantidad de empleados y sus sueldos, posteriormente solo te quedara sacar el progrmedio.

Saludos!

Jajajaja, ya me imagino, No me comaaa serñor fflush(stdin); ya voy a utiliza  fseek(stdin, 0, SEEK_END); como indican en ¿Queda algo en el Buffer de Entrada stdin? (Solucionado)

Por cierto date una vuelta por este tema: Lo que no hay que hacer en C/C++. Nivel basico

Saludos!

registro no devulve ningun tipo de dato. eso da error, ademas R es solo un caracter y no una cadena o algun otro tipo.

La concatenacion de candenas podrias realizarla mas rapido de la siguiente manera:

sprintf(nombrecompleto,"%s %s %s",nom,ape,apeM);

Saludos!

En teoría quedo esta versión, utilizando un buffer semi circular y creciendo la memoria en potencias de 2.

Tiene muchos printf para depuración, y mostrar el funcionamiento.

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<time.h>
 
typedef struct str_queue	{
	char **queue;
	int len;
	/*
		Las siguientes variales son para hacer mas eficiente la asignacion de memoria
		len_max indica el numero de espacios len_maximos reservados actualmente, este siempre esta en potencias de 2
		offset indica cuantos espacios vacios hay al principio del arreglo, con el fin de no tener que reacomodar el arreglo con cada de-queue
		offset_max indica la cantidad cada cuantos movimientos se va a reorganizar la memoria.
	*/
	int len_max;
	int offset;
	int offset_max;
}Queue;	
 
Queue *create_queue()	{
	Queue *q = malloc(sizeof(struct str_queue));
	q->len = 0;
	q->offset = 0;
	q->len_max = 2;
	q->offset_max = 1;
	q->queue = malloc(sizeof(char*)*q->len_max);
	return q;
}
 
void free_queue(Queue *q)	{
	if(q)	{
		if(q->queue)
			free(q->queue);
		free(q);
	}
}
 
void en_queue(Queue *q, char *ptr)	{
	char **temp;
	int i;
	//printf("%i == %i ?\n",q->len,q->len_max);
	if( q->len == q->len_max)	{
		q->len_max *= 2;
		//printf("%p -> ",q->queue);
		temp = q->queue;
		q->queue = realloc(temp,q->len_max*sizeof(char*));
		//printf("%p\n",q->queue);
 
		if(q->queue == NULL)	{
			fprintf(stderr,"error realloc\n");
		}
		else	{
			printf("Tamanio actual %i\n",q->len_max);
		}
	}
	if(q->queue != NULL)	{
		printf("q->queue[%i] <- %p\n",q->len,ptr);
		q->queue[q->len] = ptr;
		q->len++;
	}
}
 
char * de_queue(Queue *q)	{
	char *r = NULL;
	int i,j;
	if((q->len - q->offset) >= 1)	{
		r = q->queue[q->offset];
		printf("q->queue[%i] : %p -> out\n",q->offset,q->queue[q->offset]);
		q->queue[q->offset] = NULL;
		q->offset++;
		if(q->offset == q->offset_max)	{
			//printf("%i == %i\n",q->offset,q->offset_max);
			i = q->offset;
			j = 0;
			//printf("i:%i  j:%i\n",i,j);
			while(i < q->len)	{
				//printf("i:%i < q->len:%i\n",i,q->len);
				printf("q->queue[%i]: %p  <- q->queue[%i]: %p\n",j,q->queue[j],i,q->queue[i]);
				q->queue[j] = q->queue[i];
				q->queue[i] = NULL;
				j++;
				i++;
			}
			//printf("%i:q->len %i -= q->offset %i\n",(q->len-q->offset),q->len,q->offset);
			q->len -= q->offset;
			q->offset = 0;
			q->offset_max *=2;
		}
	}
	//printf("r: %p, %s\n",r,r);
	return r;
}
 
int main()	{
	char *cadenas[10] = { "Cadena_0","Cadena_1","Cadena_2","Cadena_3","Cadena_4","Cadena_5","Cadena_6","Cadena_7","Cadena_8","Cadena_9"};
	char *actual;
	int index1,index2,i =0;
	srand(time(NULL));
	Queue *q = create_queue();
	while(i < 1000)	{
		index1 = rand() % 10;
		index2 = rand() % 10;
		//printf("Agregando a la fila: %p %s\n",cadenas[index1],cadenas[index1]);
		en_queue(q,cadenas[index1]);
		//printf("Agregando a la fila: %p %s\n",cadenas[index2],cadenas[index2]);
		en_queue(q,cadenas[index2]);
		de_queue(q);
		//printf("Saliendo de la fila %s\n",de_queue(q));
		i++;
	}
	free_queue(q);
}
 

Salidos!

Por lo mismo lo dije:


Si claramente se puede manejar de mejor manera, me gusta lo de pedir memoria en potencias de 2, y lo del buffer Circular.

Pidiendo memoria de 2 en 2, requiere cambios en la estructura, en la funcion de crear para inicializar con 2 espacios disponibles y en la funcion en_queue

typedef struct str_queue	{
	char **queue;
	int len;
	int max;
}Queue;
 
Queue *create_queue()	{
	Queue *r = malloc(sizeof(struct str_queue));
	r->len = 0;
	r->max = 2;
	r->queue = malloc(sizeof(char*)*r->max);
	return r;
}
 
void en_queue(Queue *q, char *ptr)	{
	if((q->len+1) == q->max)	{
		q->max *= 2;
		printf("Tamanio actual %i\n",q->max);
		q->queue = realloc(q->queue,q->max*sizeof(char*));	
	}
	if(q->queue != NULL)	{
		q->queue[q->len] = ptr;
		q->len++;
	}
}
 

Saludos!

Muy buen dia.

Estoy trabajando con un servidor http de lo mas básico posible.

Tengo un error al momento de enviar el contenido. El navegador a veces recibe los archivos incompletos y no logro ubicar el error.



El navegador indica que solo recibe 768KB para el penultimo archivo "/test.mp3"

La salida del programa indica lo siguiente para ese archivo.



Leido indica la cantidad de bytes que a leido desde el archivo:

			fseek(contenido,offset,SEEK_SET);
			leido = fread(buffer,1,size,contenido);
			printf("Leido %i %s\n",leido,path);
			if(leido != size)	{
				fprintf(stderr,"fread() read %i vs request %i\n",leido,size);
				exit(0);
			}
			fclose(contenido);
 

leido toma la cantidad que devuelve fread, si leido y size son distintos el programa termina inmediatamente.


Posteriormente mando ese buffer leido al comando send.

int send_all(SOCKET descriptor, const void *buffer, size_t length, int flags)	{
	printf("send_all\n");
    ssize_t n;
    const char *p = buffer;
    while (length > 0)
    {
        n = send(descriptor, p, length, flags);
		printf("send: %i bytes\n",n);
        if (n <= 0)
            return -1;
        p += n;
        length -= n;
    }
    return 0;
}
 

send all indica mediante la variable "n" la cantidad de datos enviados por send.

Asi mismo en los headers recibe correctamente el mismo numero indicado por el programa:



Asi que dado que la cantidad de items leidos por fread es la misma que la cantidad de bytes enviados por send, no entiendo por que el navegador no recibe todo el archivo, ya que al momento de tratar de reproducirlo esta incompleto.

Saludos

---

Al final quedo solucionado modificando la funcion send all. Por alguna razon dice que a enviado todos lo 2 MB pero el navegador  solo recibio los 700 KB. Modique la funcion para que envie de 64 bytes por vez y ahora envio el documento completo

int send_all(SOCKET descriptor, const void *buffer, int length, int flags)	{
	int n,s;
	const char *p = buffer;
	while (length > 0)	{
		s = ( length > 64 ) ? 64: length; 
		n = send(descriptor, p, s, flags);
		if (n <= 0)
			return -1;
		p += n;
		length -= n;
	}
	return 0;
}

Y el programa marca exactamente la misma cantidad.


Saludos!

Gracias, si no lo compile, solo lo edite y se me olvido editar el prototipo.

Saludos

Si me imagine que si la implementación empieza de alravez puede pasar eso, lo voy editar como mentas o en su defecto con una versión iterativa con while moviendo los elementos del buffer.

char * de_queue(Queue *q)	{
	char *r = NULL;
	int i = 0;
	if(q->len >= 1)	{
		r = q->queue[0];
		q->len--;
		while(i < q->len)	{
			q->queue[i] = q->queue[i+1];
			i++;
		}
		q->queue[i] = NULL;
	}
	return r;
}
 

Por mala practica de programación, viejo habito de declarar las funciones como int, cuando no he definido si van a retornar valor o no.

En un momento corrijo el código.

Saludos!

Por ahi hubieras empezado.

Esta el siguiente tema donde se dan algunos temas para aprender.

https://foro.elhacker.net/programacion_cc/avanzar_en_programacion_de_c_de_manera_escalonada-t490166.0.html

Si estas viendo C  date una vuelta por el siguiente tema:

https://foro.elhacker.net/programacion_cc/plantillas_programas_escolares_en_c-t489889.0.html

Ahi muestro algunas plantillas básicas que siempre piden en trabajos escolares.

Por ahi en mas te recomiendo un  libro de C


 y cualquier dudas aqui estamos

Saludos!

 

int main()

---

Fuera de bromas, por lo menos dinos si tienes el archivo.

Ya sabes leer archivos, desde C o estas viendo C++?

Saludos!