Mensajes

No es necesario complicarse tanto puedes añadir una llamada a function en tu libreria:

srand...

Y el usuario seguiria ejecutando la misma funcion sin interacción con esa función: cómodo, práctico y sencillo.

Aunque el problema parece resolvido, podrías incluso hacerlo usando una única variable:

Código (c) [Seleccionar] Expandir

int numero = 0;
while(cin +>> numero) if((cin +>>numero) == 0)break; else continue; // para finalizar poner un numero negatio suficientemente alto.

Mira el uso de listas enlazadas y pilas. Puedes buscarlo en google.

Gracias por el aporte @ivancea96, claro que me sirve, aunque no uso C++, y la orienzación a objetos lo sustituyo por un struct que contenga la llamada a las funciones (intentando imitar programación con objetos, por ejemplo socket.conectar("127.0.0.1", 8080)), aunque estoy planteándome el uso de funciones predefinidas que obtengan como parámetro la estructura que contenga el socket y la estructura sockaddr_in.

Los principales motivos por el cual quiero usar funciones predefinidas es para ahorrarme crear una estructura que contenga 7 punteros que deben ser inicializados cada vez que cree una nueva estructura.

Publicaré el código cuando lo tenga como un aporte. Estoy puliendo crear una función, que no necesita explicación: create_server_single_addrany.

Saludos.

Creo este tema para que aporten idea, una mejor solución o cualquier cosa que puedan aportar para mejorar esta pequeña idea.

En cuestión quiero crear una librería para simplificar el uso de sockets, en otra palabras, hacer las cosas más cómodamente.

La estructura general de la librería se compone de una estructura que almacena datos del socket; una estructura candidata posible podría ser algo como:

Código (c) [Seleccionar] Expandir

typedef int socket;

typedef struct libreria_socket {
socket socket_fd;
struct sockaddr_in host;
} socket;

La segunda cosa fundamental será la inicialización de esa estructura. Para ello necesitamos 2 funciones auxiliares que recibirán los parametros directamente desde una función principal iniciar_socket; la primera de ellas crear_socket, supongamos que AF (Adress Format) es INET (IP y puerto): AF_INET; la segunda de ellas podría tener 2 variantes: iniciar_sockaddr e iniciar_sockaddrany. La diferencia de estas es que en la estructura sockaddr_in, sin_addr atendería en todo el rango: 127.0.0.1/24.

Funciones secundarias, que bien podrían servir para formar parte de una función principal que automatice el proceso dependiendo de las necesidades del usuario final ó para tener el código más organizado, limpio, estético y hacer las cosas más sencillas. Estas son las funciones conectar_socket, bind_socket, escuchar_socket, aceptar_socket (esta según lo anterior también podría tener dos variantes: aceptar_socket y aceptar_socket_addrany), cerrar_socket.

Las funciones de lectura y escritura pueden usarse nativamente. Un pseudocódigo de cómo funcionaría la librería según las ideas que tengo ahora mismo:

Código (c) [Seleccionar] Expandir

socket socket_test;

iniciar_socket(&socket_test, 8080 /* puerto */, "127.0.0.1" /* direccion ip */);
conectar_socket(&socket_test);

char buffer[1024];

// Recibir datos
read(socket_test.socket_fd, buffer, 1024);

// Reenviar datos
write(socket_test.socket_fd, buffer, 1024);

De momento eso es todo. Aporten ideas, comentarios, soluciones, otra forma de hacerlo...

Saludos.

También es verdad que si de inicio vamos a saber los bytes, o al menos, una aproximación de los bytes que ocuparemos en memoria entonces creo que hay maneras más óptimas de programar en ese caso.

¿Ineficiente porqué?, si el tamaño medio de datos a cojer es de 50Mb puedo almacenar los datos en esos 50Mb de datos, el programador decide si almacenarlo en 1 Array, o en 500 Arrays.

No incremento 16Mb por realloc. Una vez ocupado los 16Mb, hago una nueva variable qie seguiria aumentando hasta los 16Mb.

No tiene razón en ese aspecto. Te explico:

Si yo limito cada array de datos a, digamos, 16Mb de datos, me aseguro que almenos mi pérdida de datos no será mayor de 8Mb. Esto es, en el momento que yo almacene 16Mb + 1byte, se pasará a otro array dinámico, es decir, en el peor caso la pérdida será de 16Mb / 2 + 1byte: 8Mb - 1byte de pérdida.

Suponiendo que tengas 1GB de datos, no creo que sea necesario guardarlo todo en un array (...)

Pero a parte de eso: Según el método de potencias de 2, si hay 1GB+1byte de elementos, acabarías ocupando 2GB de RAM, que no es una broma. Y es sólo un ejemplo.

Y repito, en ningún momento he hablado yo de arrays estáticos. Siempre he hablado de dinámicos y he orientado todo lo que he dicho a arrays dinámicos.

No se trata de obtener el tamaño del array que vamos a necesitar, se trata de obtener el incremento en el realloc.

Te respondo con algo que ya escribí:

En cuanto a almacenar 1GB de datos para luego convertirlos a 2GB sólo por añadir 1 datos más eso es problema del programador. Me explico, aunque es irrazonable crear un array de 1GB para estudiarlo u operar con él, el programador debería definir un tamaño máximo de memoria ocupada por array para que no pasen esas cosas, es decir, dividir en varios segmentos el sistema total.