Iniciado por
akualung
Tienes razón, no me había fijado en el bucle donde el tío ha metido ahí, hardcodeado, el tamaño del array que recibe esa función. Pero pregunto, y de ahí lo que he dicho antes de "caduco". si en C le pasas un array a una función (un array que se supone que viene ya con una serie de valores dentro y por lo tanto, ya tendrá un tamaño determinado) por qué has de pasar el tamaño del array como otro parámetro adicional en vez de simplemente sacarlo de alguna manera similar como se hace en programación orientada a objetos con un sencillo arrayQueAcabamosDeRecibir.length()?
Sí, lo sé: programación orientada a objetos != programación estructurada... Pero aún así. Encuentro muy fuerte que, en C, si pasas un array a una función, "pierdas" su tamaño y por lo tanto lo tengas que enviar como un parámetro adicional (si es que he entendido bien el error que le está pasando a OP).
como dices, es diferente, en C no hay objetos...
tiene su logica, aunque es un poco complejo de explicar, veamos...
partamos de la base de que sizeof se resuelve en tiempo de compilacion, no hay una funcion sizeof como tal, sino que el compilador la resuelve y coloca el valor constante en ese lugar del codigo. entonces, C no necesita almacenar el tamaño del array para ser accedido en runtime, asi que no hay forma de saber el tamaño del array en una funcion.
tambien decir que no son objetos, lo que pasas es el dato en si, en el caso de arrays, se pasa el puntero (tampoco se pasa el array por valor, solo por referencia), aunque podrias si quieres pasar una estructura del tipo [ int size; int * array ], tendrias casi un objeto...
Código:
#include <stdio.h>
typedef struct {
int sz;
int * array;
} blah;
void multiply(blah a, blah b){
printf("\nTamaño de a = %d\n", a.sz);
printf("Tamaño de b = %d\n", b.sz);
printf("a[0]=%d\n", a.array[0]);
printf("b[1]=%d\n", b.array[1]);
}
int main(int argc, const char * argv[]) {
int a[] = { 9, 2, 3, 4, 5, 6, 7, 8 };
int b[] = { 4, 3, 2, 1 };
int a1[] = { 13, 53, 44, 1 };
int b1[] = { 99, 33 };
blah blah_a, blah_b;
printf("sizeof(int)=%lu\n", sizeof(int));
blah_a.sz = sizeof(a)/sizeof(*a); blah_a.array = a;
blah_b.sz = sizeof(b)/sizeof(*b); blah_b.array = b;
printf("Tamaño de a = %d\n", (int)(sizeof(a)/sizeof(int)));
printf("Tamaño de b = %d\n", (int)(sizeof(b)/sizeof(int)));
multiply(blah_a,blah_b);
printf ("------------\n");
blah_a.sz = sizeof(a1)/sizeof(*a1); blah_a.array = a1;
blah_b.sz = sizeof(b1)/sizeof(*b1); blah_b.array = b1;
printf("Tamaño de a1 = %d\n", (int)(sizeof(a1)/sizeof(int)));
printf("Tamaño de b1 = %d\n", (int)(sizeof(b1)/sizeof(int)));
multiply(blah_a,blah_b);
return 0;
}
resultado:
sizeof(int)=4
Tamaño de a = 8
Tamaño de b = 4
Tamaño de a = 8
Tamaño de b = 4
a[0]=9
b[1]=3
------------
Tamaño de a1 = 4
Tamaño de b1 = 2
Tamaño de a = 4
Tamaño de b = 2
a[0]=13
b[1]=33
despues podriamos decir que una funcion donde hace uso de sizeof (resuelto en tiempo de compilacion) de sus parametros arrays, carece de reutilidad para arrays de diferentes sizes...
el ejemplo es una tonteria, pero bueno, para ejemplificar opciones...
-----Actualizado-----
veo que @AJMurphy solo tiene un mensaje, seguramente entro al foro para consultar y puso esta consulta en cientos de sitios, y tal vez ya le respondieron en otro lugar...
Marcadores