Почему размер массива не такой же, как и у основного?

Почему размер массива, отправленного как параметр, не совпадает с размером основного?

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

Нет , массив-тип неявно преобразуется в тип указателя, когда вы передаете его функции.

Так,

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

а также

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

эквивалентны. Итак, вы получаете значение sizeof(int*)

Это указатель, поэтому общая реализация позволяет передать размер массива в качестве второго параметра функции

Как утверждали другие, массивы распадаются на указатели на их первый элемент при использовании в качестве параметров функции. Также стоит отметить, что sizeof не оценивает выражение и не требует скобок при использовании с выражением, поэтому ваш параметр фактически не используется вообще, поэтому вы можете также написать sizeof с типом, а не с значением.

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

Таким образом, вам нужно будет передать длину массива в качестве второго параметра. Когда вы пишете код, в котором вы объявляете массив постоянного размера, а затем передаете этот массив функции, больно, чтобы константа длины массива отображалась в нескольких местах вашего кода …

K & R на помощь:

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

Итак, теперь вы можете сделать, например:

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

Поскольку массивы распадаются на указатели, когда они передаются в качестве параметров. Вот как работает C, хотя вы можете передавать «массивы» на C ++ по ссылке и преодолевать эту проблему. Обратите внимание, что вы можете передавать массивы разных размеров этой функции:

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

В c ++ вы можете передать массив по ссылке для этой цели:

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

Поведение, которое вы обнаружили, на самом деле является большой бородавкой на языке C. Всякий раз, когда вы объявляете функцию, которая принимает параметр массива, компилятор игнорирует вас и изменяет параметр на указатель. Таким образом, эти объявления ведут себя как первый:

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

a будет указателем на int во всех четырех случаях. Если вы передадите массив в func, он немедленно распадается на указатель на его первый элемент. (В 64-разрядной системе 64-разрядный указатель в два раза больше, чем 32-битный int, поэтому коэффициент sizeof возвращает 2.)

Единственная цель этого правила – поддерживать обратную совместимость с историческими компиляторами, которые не поддерживают передачу агрегированных значений в качестве аргументов функции.

Это не означает, что передать массив в функцию невозможно. Вы можете обойти эту бородавку, вставив массив в структуру (это в основном цель std :: array C ++ 11):

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

или передавая указатель на массив:

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

Если размер массива не является константой времени компиляции, вы можете использовать метод указатель-массив с массивами переменной длины C99:

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

На языке C нет способа определить размер неизвестного массива, поэтому необходимо передать количество, а также указатель на первый элемент.

Вы не можете передавать массивы в функции.

Если вы действительно хотите напечатать размер, вы можете передать указатель на массив, но он не будет вообще общим, поскольку вам также необходимо определить размер массива для функции.

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

Поведение по дизайну.

Такой же синтаксис в объявлении параметра функции означает совершенно другую вещь, чем в определении локальной переменной.

Причина объясняется другими ответами.

В языке C, когда вы передаете массив в качестве аргумента функции, он автоматически преобразуется в указатель, массив переходит из одной функции, другая функция известна как вызов по ссылке. Именно по этой причине вызываемая функция получает только указатель, указывающий на первый элемент функции. Это причина

fun (int a []) похож на fun (int * a);

поэтому, когда вы печатаете размер массива, он будет печатать размер первого элемента.

В программировании ‘C’ languange ‘sizeof ()’ является оператором, и он возвращает размер объекта в байтах. Параметр оператора sizeof () должен быть левым типом (integer, float number, struct, array ). Так что, если вы хотите знать размер массива в байтах, вы можете сделать это очень просто. Просто используйте оператор sizeof () и для его аргумента используйте имя массива. Например:

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

Выход на 32-битной системе будет: Размер n равен: 40.Because ineteger на 32-й системе – 4 байта. В 64x это 8bytes. В этом случае у нас есть 10 целых чисел, объявленных в одном массиве. Таким образом, результат равен ’10 * sizeof ( целое).

Некоторые советы:

Если у нас есть массив, объявленный таким образом: ‘int n [] = {1, 2, 3, … 155 ..};’. Поэтому мы хотим знать, сколько элементов хранится в этом массиве. Используйте этот алгоритм:

sizeof (name_of_the_array) / sizeof (array_type)

Код: #include

главный(){

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

}

Массивы имеют только размеры. По большей части массив является указателем на память. Размер в объявлении сообщает компилятору, сколько памяти выделяется для массива – оно не связано с типом, поэтому sizeof () не имеет ничего общего.

Interesting Posts
Давайте будем гением компьютера.