¿Por qué el tamaño de un parámetro de matriz no es el mismo que el de main?

¿Por qué no se envía el tamaño de una matriz como un parámetro igual que en main?

#include  void PrintSize(int p_someArray[10]); int main () { int myArray[10]; printf("%d\n", sizeof(myArray)); /* As expected, 40 */ PrintSize(myArray);/* Prints 4, not 40 */ } void PrintSize(int p_someArray[10]){ printf("%d\n", sizeof(p_someArray)); } 

No , array-type se convierte implícitamente en un tipo de puntero cuando lo pasa a una función.

Asi que,

 void PrintSize(int p_someArray[10]) { printf("%zu\n", sizeof(p_someArray)); } 

y

 void PrintSize(int *p_someArray) { printf("%zu\n", sizeof(p_someArray)); } 

son equivalentes. Entonces, lo que obtienes es el valor de sizeof(int*)

Es un puntero, por eso es una implementación común pasar el tamaño de la matriz como un segundo parámetro a la función

Como han indicado otros, las matrices decaen a los punteros a su primer elemento cuando se usan como parámetros de función. También vale la pena señalar que sizeof no evalúa la expresión y no requiere paréntesis cuando se utiliza con una expresión, por lo que su parámetro no se está utilizando en absoluto, por lo que también puede escribir el tamaño con el tipo en lugar del valor.

 #include  void PrintSize1 ( int someArray[][10] ); void PrintSize2 ( int someArray[10] ); int main () { int myArray[10]; printf ( "%d\n", sizeof myArray ); /* as expected 40 */ printf ( "%d\n", sizeof ( int[10] ) ); /* requires parens */ PrintSize1 ( 0 ); /* prints 40, does not evaluate 0[0] */ PrintSize2 ( 0 ); /* prints 40, someArray unused */ } void PrintSize1 ( int someArray[][10] ) { printf ( "%d\n", sizeof someArray[0] ); } void PrintSize2 ( int someArray[10] ) { printf ( "%d\n", sizeof ( int[10] ) ); } 

Por lo tanto, deberá pasar la longitud de la matriz como un segundo parámetro. Cuando está escribiendo código, en el que declara una matriz de tamaño constante y luego lo transfiere a una función, es una molestia tener la constante de longitud de matriz en varios lugares de su código …

K & R al rescate:

 #define N_ELEMENTS(array) (sizeof(array)/sizeof((array)[0])) 

Así que ahora puedes hacer, por ejemplo:

 int a[10]; ... myfunction(a, N_ELEMENTS(a)); 

Porque las matrices decaen en punteros cuando se pasan como parámetros. Así es como funciona C, aunque puede pasar “matrices” en C ++ por referencia y superar este problema. Tenga en cuenta que puede pasar matrices de diferentes tamaños a esta función:

  // 10 is superfluous here! You can pass an array of different size! void PrintSize(int p_someArray[10]); 

En c ++ puede pasar una matriz por referencia para este mismo propósito:

 void foo(int (&array)[10]) { std::cout << sizeof(array) << "\n"; } 

El comportamiento que encontraste es en realidad una gran verruga en el lenguaje C. Cada vez que declara una función que toma un parámetro de matriz, el comstackdor lo ignora y lo cambia a un puntero. Entonces todas estas declaraciones se comportan como la primera:

 void func(int *a) void func(int a[]) void func(int a typedef int array_plz[5]; void func(array_plz a) 

a será un puntero a int en los cuatro casos. Si pasa una matriz a func, inmediatamente se descompondrá en un puntero a su primer elemento. (En un sistema de 64 bits, un puntero de 64 bits es dos veces más grande que un int de 32 bits, por lo que su ratio de tamaño vuelve a 2.)

El único propósito de esta regla es mantener la compatibilidad con comstackdores históricos que no admitían el paso de valores agregados como argumentos de función.

Esto no significa que sea imposible pasar una matriz a una función. Puede evitar esta verruga insertando la matriz en una estructura (este es básicamente el propósito de std :: array de C ++ 11):

 struct array_rly { int a[5]; }; void func(struct array_rly a) { printf("%zd\n", sizeof(aa)/sizeof(aa[0])); /* prints 5 */ } 

o pasando un puntero a la matriz:

 void func(const int (*a)[5]) { printf("%zd\n", sizeof(*a)/sizeof((*a)[0])); /* prints 5 */ } 

En caso de que el tamaño de la matriz no sea una constante en tiempo de comstackción, puede usar la técnica de puntero a matriz con arreglos de longitud variable C99:

 void func(int n, const int (*a)[n]) { printf("%zd\n", sizeof(*a)/sizeof((*a)[0])); /* prints n */ } 

En el lenguaje C, no hay un método para determinar el tamaño de una matriz desconocida, por lo que la cantidad debe pasarse, así como un puntero al primer elemento.

No puede pasar matrices a las funciones.

Si realmente desea imprimir el tamaño, puede pasar un puntero a una matriz, pero no será genérico en absoluto, ya que también necesita definir el tamaño de la matriz para la función.

 #include  void PrintSize(int (*p_anArray)[10]); int main(void) { int myArray[10]; printf("%d\n", sizeof(myArray)); /* as expected 40 */ PrintSize(&myArray);/* prints 40 */ } void PrintSize(int (*p_anArray)[10]){ printf("%d\n", (int) sizeof(*p_anArray)); } 

El comportamiento es por diseño.

La misma syntax en la statement del parámetro de función significa algo completamente diferente que en la definición de variable local.

El motivo se describe en otras respuestas.

En el lenguaje C cuando pasa la matriz como un argumento a la función, se convierte automáticamente en un puntero, una serie que pasa de una función a otra función se conoce como llamada por referencia. Esa es la razón por la cual la función llamada solo recibe el puntero, que apunta al primer elemento de función. Este es el motivo

fun (int a []) es similar a fun (int * a);

así que cuando imprima el tamaño de la matriz, imprimirá el tamaño del primer elemento.

En la progtwigción ‘C’ languange ‘sizeof ()’ es el operador y él devuelve el tamaño del objeto en bytes. El argumento del operador ‘sizeof ()’ debe ser un tipo de valor a la izquierda (entero, número flotante, struct, matriz ). Así que si quieres saber el tamaño de una matriz en bytes, puedes hacerlo de manera muy simple. Solo usa el operador ‘sizeof ()’ y para su argumento usa el nombre de la matriz. Por ejemplo:

 #include  main(){ int n[10]; printf("Size of n is: %d \n", sizeof(n)); } 

La salida en el sistema de 32 bits será: El tamaño de n es: 40. Debido a que el sistema ineteger en 32 es de 4 bytes. En 64x es 8 bytes. En este caso, tenemos 10 enteros declarados en una matriz. Por lo tanto, el resultado es ’10 * sizeof ( En t)’.

Algunos consejos:

Si tenemos una matriz declarada como esta ‘int n [] = {1, 2, 3, … 155 ..};’. Entonces queremos saber cuántos elementos están almacenados en esta matriz. Usa este alghorithm:

sizeof (name_of_the_array) / sizeof (array_type)

Código: #include

principal(){

 int n[] = { 1, 2, 3, 44, 6, 7 }; printf("Number of elements: %d \n", sizeof(n) / sizeof(int)); return 0; 

}

Las matrices solo son de tamaño libre. En su mayor parte, una matriz es un puntero a la memoria. El tamaño en su statement solo le dice al comstackdor cuánta memoria asignar para la matriz – no está asociado con el tipo, por lo que sizeof () no tiene nada para continuar.