Por que o tamanho de um parâmetro de array não é o mesmo que o main?

Por que o tamanho de uma matriz é enviado como um parâmetro igual ao 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)); } 

Não , o tipo de matriz é implicitamente convertido em tipo de ponteiro quando você o passa para uma function.

Assim,

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

e

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

são equivalentes. Então, o que você obtém é o valor de sizeof(int*)

É um ponteiro, é por isso que é uma implementação comum para passar o tamanho da matriz como um segundo parâmetro para a function

Como outros afirmaram, as matrizes decaem em pointers para o primeiro elemento quando usados ​​como parâmetros de function. Também é importante notar que sizeof não avalia a expressão e não requer parênteses quando usado com uma expressão, então seu parâmetro não está realmente sendo usado, então você pode também escrever o tamanho com o tipo em vez do 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] ) ); } 

Então, você precisará passar o comprimento da matriz como um segundo parâmetro. Quando você está escrevendo código, no qual ambos declaram uma matriz de tamanho constante e depois passam essa matriz para uma function, é difícil ter a constante de comprimento de matriz mostrando vários locais em seu código …

K & R para o resgate:

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

Então agora você pode fazer por exemplo:

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

Porque matrizes decaem em pointers quando são passados ​​como parâmetros. É assim que funciona o C, embora você possa passar “arrays” em C ++ por referência e superar esse problema. Observe que você pode transmitir matrizes de tamanhos diferentes para essa function:

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

Em c ++ você pode passar um array por referência para este propósito:

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

O comportamento que você encontrou é na verdade uma grande verruga na linguagem C. Sempre que você declara uma function que usa um parâmetro de matriz, o compilador o ignora e altera o parâmetro para um ponteiro. Então todas essas declarações se comportam como a primeira:

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

a será um ponteiro para int nos quatro casos. Se você passar um array para func, ele decairá imediatamente em um ponteiro para o primeiro elemento. (Em um sistema de 64 bits, um ponteiro de 64 bits é duas vezes maior que um int de 32 bits, portanto, sua proporção de tamanho retorna 2).

O único propósito dessa regra é manter compatibilidade retroativa com compiladores históricos que não suportam a passagem de valores agregados como argumentos de function.

Isso não significa que é impossível passar um array para uma function. Você pode contornar essa verruga incorporando a matriz em uma estrutura (basicamente é a finalidade do std :: array do C ++ 11):

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

ou passando um ponteiro para o array:

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

Caso o tamanho da matriz não seja uma constante de tempo de compilation, você pode usar a técnica de ponteiro para matriz com matrizes de comprimento variável C99:

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

Na linguagem C, não existe um método para determinar o tamanho de um array desconhecido, então a quantidade precisa ser passada assim como um ponteiro para o primeiro elemento.

Você não pode passar matrizes para funções.

Se você realmente quisesse imprimir o tamanho, você poderia passar um ponteiro para um array, mas ele não seria genérico, já que você precisa definir o tamanho do array para a function também.

 #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)); } 

O comportamento é por design.

Mesma syntax na declaração de parâmetro de function significa coisa completamente diferente do que na definição de variável local.

O motivo é descrito em outras respostas.

Na linguagem C, quando você passa a matriz como um argumento para a function, ela é automaticamente convertida em ponteiro, a matriz passando de uma function outra function é conhecida como chamada por referência. Essa é a razão pela qual a function chamada recebe apenas o ponteiro que aponta para o primeiro elemento da function. Esta é a razão

fun (int a []) é semelhante a diversão (int * a);

Então, quando você imprime o tamanho do array, ele imprime o tamanho do primeiro elemento.

Na linguagem de programação ‘C’ ‘sizeof ()’ é o operador e ele retorna o tamanho do object em bytes. O argumento do operador ‘sizeof ()’ deve ser um tipo de valor à esquerda (integer, float number, struct, array ) .Então, se você quiser saber o tamanho de uma matriz em bytes, você pode fazê-lo muito simples. Basta usar o operador ‘sizeof ()’ e para seu argumento usar o nome da matriz.Por exemplo:

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

Saída no sistema de 32 bits será: O tamanho de n é: 40.Porque ineteger no sistema 32 é 4bytes.On 64x é 8bytes.Neste caso, temos 10 inteiros declarados em uma matriz.Assim, o resultado é ’10 * sizeof ( int) ‘.

Algumas dicas:

Se temos um array declarado como este ‘int n [] = {1, 2, 3, … 155 ..};’. Então, queremos saber quantos elementos estão armazenados nessa matriz. Use este alorcitmo:

sizeof (name_of_the_array) / sizeof (array_type)

Código: #include

a Principal(){

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

}

As matrizes são apenas de tamanho pequeno. Na maior parte, uma matriz é um ponteiro para a memory. O tamanho em sua declaração apenas informa ao compilador a quantidade de memory a ser alocada para a matriz – ela não está associada ao tipo, portanto, sizeof () não tem nada a seguir.