Mensajes

Muy buenas:

Por lo pronto se me ocurre lo siguiente:
Hacer una función que compare dos productos.

Código (c) [Seleccionar] Expandir

int comparar_producto(const void *p1, const void *p2) {
    articulo *art1 = (articulo*) p1;
    articulo *art2 = (articulo*) p2;
    return strcmp(art1->nombre, art2->nombre);
}

Y finalmente usas la función qsort, de stdlib, para que te ordene ella sola el array.

Código (c) [Seleccionar] Expandir

qsort(productoArray[], pLength, sizeof(producto), comparar_producto);

Muy buenas.

Las constantes de cadena se guardan en una posición de memoria que C dedica para las constantes. Cuando asignas así una cadena a un puntero no varías una posición de memoria sino que apuntas a una zona de memoria que no va a cambiar en todo el programa.

Tu función recoge un puntero y por tanto podrías modificar en dicha función a lo que hay en esa zona de memoria que apunta el puntero, pero el puntero en sí, al ser una copia, aunque lo cambies dentro de la función, en main seguirás teniendo el valor original. Si quieres cambiarlo de la forma que quieres hacerlo pásalo con un puntero a puntero, entonces podrás cambiar hacia a donde apunta.

Una cosa a tener en cuenta: si lo haces de esta forma la cadena que dejes huérfana será un lastre: su memoria estará ocupada y el programa no la va a poder reclamar para darle otro uso, pero no podrás acceder a ella más pues habrás perdido su dirección al dar otro valor al puntero.

Sí, pero apuntaba a que no se ve, en C, ese tipo de construcción: int[5], por ejemplo, es mas tipo notación de C#, como en

Código (csharp) [Seleccionar] Expandir

int[] v = new int[5]; pero sin embargo es válida y muy parecida 

Código (c) [Seleccionar] Expandir

int* p = malloc(sizeof(int[5]));

La cosa es que planteas el problema, muestras lo que tienes realizado hasta el momento y especificas dónde te has quedado trabado.
La gente te va a resolver dudas puntuales, no a hacer la tarea. 

Muy buenas.

Para resolver tu problema lo que podrías hacer es leer el archivo línea a línea con fgets y, sobre la cadena adquirida, usar la función strtok con el separador + para recoger cada subcadena.

Muy buenas.

Pues bien, hay varias cosas que te fallan en el código, a saber:

1. Llamas a la función con los argumentos a, b, c y d; pero dentro de ella les das unos valores nuevos que, por otra parte, son locales de la función, no podrás saber que has guardado fuera de ella. Por tanto:
1.1. Llama a la función sin argumentos y declaras dentro de ella las cuatro variables. O
1.2. Haz que los argumentos sean punteros o referencias, entonces los valores que les des dentro de la función serán los que verás en esas mismas variables cuándo ésta regrese.

2. Dentro de la función la lógica está mal planteada: después de pedir las variables hay una cadena que pide al usuario que vuelva a introducir los datos, estén estos bien o no. Eso debería formar parte de la parte del tratamiento de error. Puedes:
2.1. Usar un if para saber si los datos introducidos son correctos, lo que tienes dentro de while. Si falla pon n2 e informa al usuario de que ha habido un fallo. Dentro del while mira si n2==0 para repetir el bucle en caso afirmativo.

3. Regresas un dato con n2 al término de la función pero, contrariamente a tu planteamiento, a juzgar por el código de main, n2 no regresa los cuatro números sino que siempre te retornará 0. Por otra parte una vez que has hecho que una función devuelva el control con return todo código que haya escrito después de esta instrucción es código que no se va a ejecutar. Puedes:
3.1. Hacer que la instrucción no devuelva nada y, junto a lo dicho en el punto 1.2. la función main recibirá los resultados en la variables usadas como argumentos de llamada. O
3.2. Hacer que la función devuelva un puntero a entero y llamarla sin argumentos. Mediante la memoria dinámica creas un array que llenarás con los cuatro números y eso será lo que devolverá la función. En main recogerás ese puntero a una variable puntero local.

No es mucha cosa, solo un divertimento; pero sirve para ver en qué parte de la memoria pone el S.O. las funciones, las variables locales, las globales y las dinámicas.
Así se puede ver como el sistema separa la memoria de código, la memoria de pila (stack) y la memoria del montón (heap).

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

char gc;
int gi;

int main(int argc, char *argv[])
{
char c;
int i;
int *p = malloc(sizeof(int));
printf("printf\t= %p\n", &printf);
printf("malloc\t= %p\n", &malloc);
printf("main\t= %p\n", &main);
printf("\n");
printf("gi\t= %p\n", &gi);
printf("gc\t= %p\n", &gc);
printf("\n");
printf("argv\t= %p\n", &argv);
printf("argc\t= %p\n", &argc);
printf("\n");
printf("c\t= %p\n", &c);
printf("i\t= %p\n", &i);
printf("p\t= %p\n", &p);
printf("\n");
for(i = 0; i < argc; ++i)
printf("argv[%i]\t= %p -- %s$\n", i, argv[i], argv[i]);
printf("\n");
printf("p (->)\t= %p\n", p);
free(p);
return 0;
}

P. ej.:

$ ./c 1 12 123 1234 12345
printf   = 0x4004f0
malloc   = 0x400520
main   = 0x40061d

gi   = 0x60105c
gc   = 0x601060

argv   = 0x7ffd71212400
argc   = 0x7ffd7121240c

c   = 0x7ffd71212413
i   = 0x7ffd71212414
p   = 0x7ffd71212418

argv[0]   = 0x7ffd71214551 -- ./c$
argv[1]   = 0x7ffd71214555 -- 1$
argv[2]   = 0x7ffd71214557 -- 12$
argv[3]   = 0x7ffd7121455a -- 123$
argv[4]   = 0x7ffd7121455e -- 1234$
argv[5]   = 0x7ffd71214563 -- 12345$

p (->)   = 0x1e36010

En la libreria ctype hay una macro que te viene muy bien:

int isdigit(int c)

devuelve un valor distinto de 0 si c es un número decimal.

Con ella repasas los caracteres de la cadena y si hay alguno que no sea un número lanzas un mensaje de error.

Cuándo se usa la función malloc, por ejemplo, y una llamada básica podría ser algo así:

int *p = malloc(sizeof(int) * 5);

Y ahora viene la parte curiosa y mi planteamiento:

int arr[5] es un array de enteros.
int (*p)[5] es un puntero a un array de 5 enteros.
Lo único que tienen en común los dos son el tipo de dato, int, y el tamaño del array, 5. El nombre que le demos no tiene imporancia. Si se obvia dicho nombre nos debería dar un tamaño pero sin declarar nada.

Por tanto el código antes escrito podría codificarse de una forma un poco más intuitiva:

int *p = malloc( sizeof(int[5]) );

Y funciona, al menos con GCC.

>>> Editado porqué estas líneas no tienen un sentido práctico <<<

También funciona:

int *p = malloc( sizeof(int[5][5]) );

y

int **p = malloc( sizeof(int[5][5]) );

>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<

¿Qué os parece?

Tal vez te falta dereferenciar el puntero:
int a = *(int*)numero;