Как определить размер моего массива в C?
Как определить размер моего массива в C?
То есть количество элементов, которое может содержать массив?
29 ответов
Управляющее резюме:
int a[17];
size_t n = sizeof(a)/sizeof(a[0]);
Чтобы определить размер вашего массива в байтах, вы можете использовать sizeofоператор:
int a[17];
size_t n = sizeof(a);
На моем компьютере длина целых 4 байта, поэтому n равно 68.
Чтобы определить количество элементов в массиве, мы можем разделить общий размер массива на размер элемента массива. Вы можете сделать это с типом, как это:
int a[17];
size_t n = sizeof(a) / sizeof(int);
и получить правильный ответ (68 / 4 = 17), но если типa изменилось бы у вас будет неприятная ошибка, если вы забыли изменить sizeof(int) также.
Таким образом, предпочтительным делителем является sizeof(a[0])размер нулевого элемента массива.
int a[17];
size_t n = sizeof(a) / sizeof(a[0]);
Еще одним преимуществом является то, что теперь вы можете легко параметризовать имя массива в макросе и получить:
#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))
int a[17];
size_t n = NELEMS(a);
sizeof это правильный путь, если вы имеете дело с массивами, не полученными в качестве параметров. Массив, отправленный в качестве параметра функции, рассматривается как указатель, поэтому sizeof вернет размер указателя, а не массива.
Таким образом, внутри функции этот метод не работает. Вместо этого всегда передавайте дополнительный параметр size_t size с указанием количества элементов в массиве.
Тестовое задание:
#include <stdio.h>
#include <stdlib.h>
void printSizeOf(int intArray[]);
void printLength(int intArray[]);
int main(int argc, char* argv[])
{
int array[] = { 0, 1, 2, 3, 4, 5, 6 };
printf("sizeof of array: %d\n", (int) sizeof(array));
printSizeOf(array);
printf("Length of array: %d\n", (int)( sizeof(array) / sizeof(array[0]) ));
printLength(array);
}
void printSizeOf(int intArray[])
{
printf("sizeof of parameter: %d\n", (int) sizeof(intArray));
}
void printLength(int intArray[])
{
printf("Length of parameter: %d\n", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}
Вывод (в 64-битной ОС Linux):
sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2
Вывод (в 32-битной ОС Windows):
sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1
Стоит отметить, что sizeof не помогает при работе со значением массива, которое распалось на указатель: даже если оно указывает на начало массива, для компилятора оно совпадает с указателем на отдельный элемент этого массива. Указатель не "запоминает" что-либо еще о массиве, который использовался для его инициализации.
int a[10];
int* p = a;
assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));
Размер "трюка" - лучший способ, который я знаю, с одним небольшим, но (для меня это главная любимая мозоль) важным изменением в использовании скобок.
Как ясно из статьи в Википедии, C's sizeof не является функцией; это оператор. Таким образом, он не требует скобок вокруг своего аргумента, если аргумент не является именем типа. Это легко запомнить, поскольку аргумент выглядит как приведенное выражение, которое также использует круглые скобки.
Итак: если у вас есть следующее:
int myArray[10];
Вы можете найти количество элементов с кодом следующим образом:
size_t n = sizeof myArray / sizeof *myArray;
Для меня это выглядит намного проще, чем альтернатива с круглыми скобками. Я также предпочитаю использовать звездочку в правой части раздела, поскольку она более краткая, чем индексирование.
Конечно, это также время компиляции, поэтому нет необходимости беспокоиться о разделении, влияющем на производительность программы. Так что используйте эту форму, где вы можете.
Всегда лучше использовать sizeof для реального объекта, когда он у вас есть, а не для типа, поскольку тогда вам не нужно беспокоиться о том, чтобы сделать ошибку и указать неверный тип.
Например, скажем, у вас есть функция, которая выводит некоторые данные в виде потока байтов, например, по сети. Давайте назовем функцию send()и заставьте его принять в качестве аргументов указатель на объект для отправки и количество байтов в объекте. Итак, прототип становится:
void send(const void *object, size_t size);
А затем вам нужно отправить целое число, поэтому вы кодируете его так:
int foo = 4711;
send(&foo, sizeof (int));
Теперь вы ввели тонкий способ выстрелить себе в ногу, указав тип foo в двух местах. Если одно изменяется, а другое нет, код ломается. Таким образом, всегда делайте это так:
send(&foo, sizeof foo);
Теперь вы защищены. Конечно, вы дублируете имя переменной, но вероятность того, что компилятор может обнаружить ее, если вы ее измените, высока.
Я бы посоветовал никогда не использовать sizeof (даже если это можно использовать), чтобы получить любой из двух разных размеров массива, либо по количеству элементов, либо в байтах, которые являются последними двумя случаями, которые я здесь показываю. Для каждого из двух размеров макросы, показанные ниже, могут быть использованы для обеспечения большей безопасности. Причина состоит в том, чтобы сделать понятным намерение кода для сопровождающих, и разницу sizeof(ptr) из sizeof(arr) на первый взгляд (что написано таким образом, неочевидно), так что ошибки очевидны для всех, кто читает код.
В этой теме были обнаружены важные ошибки: https://lkml.org/lkml/2015/9/3/428
Я не согласен с решением, которое предлагает Линус, которое никогда не использует нотацию массива для параметров функций.
Мне нравится обозначение массива в качестве документации, что указатель используется в качестве массива. Но это означает, что необходимо применять надежное решение, чтобы невозможно было написать ошибочный код.
Из массива у нас есть три размера, которые мы могли бы знать:
- Размер элементов массива
- Количество элементов в массиве
- Размер в байтах, который массив использует в памяти
Размер элементов массива
Первый очень прост, и не имеет значения, имеем ли мы дело с массивом или указателем, потому что это делается так же.
Пример использования:
void foo(ptrdiff_t nmemb, int arr[static nmemb])
{
qsort(arr, nmemb, sizeof(arr[0]), cmp);
}
qsort() нужно это значение в качестве третьего аргумента.
Для двух других размеров, которые являются темой вопроса, мы хотим убедиться, что мы имеем дело с массивом, и прервать компиляцию, если нет, потому что, если мы имеем дело с указателем, мы получим неправильные значения, Когда компиляция будет прервана, мы сможем легко увидеть, что мы имеем дело не с массивом, а с указателем, а нам просто нужно написать код с переменной или макросом, который хранит размер массив за указателем.
Количество элементов в массиве
Этот является наиболее распространенным, и многие ответы предоставили вам типичный макрос ARRAY_SIZE:
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
Учитывая, что результат ARRAY_SIZE обычно используется со знаковыми переменными типа ptrdiff_t, хорошо определить подписанный вариант этого макроса:
#define ARRAY_SSIZE(arr) ((ptrdiff_t)ARRAY_SIZE(arr))
Массивы с более чем PTRDIFF_MAX члены будут давать недопустимые значения для этой подписанной версии макроса, но после чтения C17::6.5.6.9 подобные массивы уже играют с огнем. Только ARRAY_SIZE а также size_t следует использовать в этих случаях.
Последние версии компиляторов, такие как GCC 8, будут предупреждать вас, когда вы применяете этот макрос к указателю, поэтому он безопасен (есть другие способы сделать его более безопасным со старыми компиляторами).
Он работает путем деления размера в байтах всего массива на размер каждого элемента.
Примеры использования:
void foo(ptrdiff_t nmemb)
{
char buf[nmemb];
fgets(buf, ARRAY_SIZE(buf), stdin);
}
void bar(ptrdiff_t nmemb)
{
int arr[nmemb];
for (ptrdiff_t i = 0; i < ARRAY_SSIZE(arr); i++)
arr[i] = i;
}
Если бы эти функции не использовали массивы, а вместо этого получили их в качестве параметров, прежний код не скомпилировался бы, поэтому было бы невозможно иметь ошибку (учитывая, что используется последняя версия компилятора или что используется какой-то другой прием) и нам нужно заменить вызов макроса значением:
void foo(ptrdiff_t nmemb, char buf[nmemb])
{
fgets(buf, nmemb, stdin);
}
void bar(ptrdiff_t nmemb, int arr[nmemb])
{
for (ptrdiff_t i = 0; i < nmemb; i++)
arr[i] = i;
}
Размер в байтах, который массив использует в памяти
ARRAY_SIZE обычно используется в качестве решения предыдущего случая, но этот случай редко пишется безопасно, возможно потому, что он менее распространен.
Обычный способ получить это значение - использовать sizeof(arr), Проблема: та же, что и с предыдущей; если у вас есть указатель вместо массива, ваша программа сойдет с ума.
Решение проблемы включает использование того же макроса, что и раньше, который, как мы знаем, безопасен (он нарушает компиляцию, если он применяется к указателю):
#define ARRAY_BYTES(arr) (sizeof((arr)[0]) * ARRAY_SIZE(arr))
Как это работает, очень просто: оно отменяет разделение, которое ARRAY_SIZE делает, так что после математической отмены вы получите только один sizeof(arr), но с дополнительной безопасностью ARRAY_SIZE строительство.
Пример использования:
void foo(ptrdiff_t nmemb)
{
int arr[nmemb];
memset(arr, 0, ARRAY_BYTES(arr));
}
memset() нужно это значение в качестве третьего аргумента.
Как и раньше, если массив получен как параметр (указатель), он не будет компилироваться, и нам придется заменить вызов макроса значением:
void foo(ptrdiff_t nmemb, int arr[nmemb])
{
memset(arr, 0, sizeof(arr[0]) * nmemb);
}
int size = (&arr)[1] - arr;
Проверьте эту ссылку для объяснения
Вы можете использовать оператор sizeof, но он не будет работать для функций, потому что он будет использовать ссылку на указатель. Чтобы найти длину массива, вы можете сделать следующее:
len = sizeof(arr)/sizeof(arr[0])
Код, изначально найденный здесь: C программа для поиска количества элементов в массиве
Если вы знаете тип данных массива, вы можете использовать что-то вроде:
int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};
int noofele = sizeof(arr)/sizeof(int);
Или, если вы не знаете тип данных массива, вы можете использовать что-то вроде:
noofele = sizeof(arr)/sizeof(arr[0]);
Примечание. Это работает, только если массив не определен во время выполнения (например, malloc) и массив не передан в функцию. В обоих случаях, arr (имя массива) является указателем.
Макрос ARRAYELEMENTCOUNT(x) что все используют оценки неправильно. На самом деле, это просто деликатный вопрос, потому что вы не можете иметь выражения, которые приводят к типу "массив".
/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))
ARRAYELEMENTCOUNT(p + 1);
На самом деле оценивается как:
(sizeof (p + 1) / sizeof (p + 1[0]));
В то время как
/* Compile as: CL /P "macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])
ARRAYELEMENTCOUNT(p + 1);
Он правильно оценивает:
(sizeof (p + 1) / sizeof (p + 1)[0]);
Это действительно не имеет непосредственного отношения к размеру массивов. Я только что заметил много ошибок из-за неправильного наблюдения за тем, как работает препроцессор Си. Вы всегда переносите параметр макроса, а не выражение, в которое может быть вовлечено.
Это правильно; мой пример был плохим. Но это именно то, что должно произойти. Как я уже говорил p + 1 будет в конечном итоге указателем типа и сделает недействительным весь макрос (как если бы вы пытались использовать макрос в функции с параметром указателя).
В конце дня, в данном конкретном случае, ошибка на самом деле не имеет значения (поэтому я просто теряю время каждого; хазз!), Потому что у вас нет выражений с типом "массив". Но на самом деле вопрос о тонкостях оценки препроцессора, я думаю, является важным.
Для многомерных массивов это немного сложнее. Часто люди определяют явные макроконстанты, т.е.
#define g_rgDialogRows 2
#define g_rgDialogCols 7
static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
{ " ", " ", " ", " 494", " 210", " Generic Sample Dialog", " " },
{ " 1", " 330", " 174", " 88", " ", " OK", " " },
};
Но эти константы могут быть оценены и во время компиляции с помощью sizeof:
#define rows_of_array(name) \
(sizeof(name ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name) \
(sizeof(name[0]) / sizeof(name[0][0]))
static char* g_rgDialog[][7] = { /* ... */ };
assert( rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);
Обратите внимание, что этот код работает на C и C++. Для массивов с более чем двумя измерениями используйте
sizeof(name[0][0][0])
sizeof(name[0][0][0][0])
и т.д. до бесконечности.
Размер массива в C:
int a[10];
size_t size_of_array = sizeof(a); // Size of array a
int n = sizeof (a) / sizeof (a[0]); // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a
// Size of each element = size of type
"Вы ввели тонкий способ выстрелить себе в ногу"
C 'родные' массивы не сохраняют свой размер. Поэтому рекомендуется сохранять длину массива в отдельной переменной / const и передавать ее всякий раз, когда вы передаете массив, то есть:
#define MY_ARRAY_LENGTH 15
int myArray[MY_ARRAY_LENGTH];
Вы ДОЛЖНЫ всегда избегать нативных массивов (если только вы не можете, в таком случае, следите за своей ногой). Если вы пишете на C++, используйте контейнер STL'vector'. "По сравнению с массивами они обеспечивают почти одинаковую производительность", и они гораздо полезнее!
// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;
// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
numbers.push_back(i);
// Determine the size of the array
cout << numbers.size();
#define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))
Если вы действительно хотите сделать это, чтобы обойти ваш массив, я предлагаю реализовать структуру для хранения указателя на тип, для которого вы хотите массив, и целого числа, представляющего размер массива. Затем вы можете передать это своим функциям. Просто назначьте этому указателю значение переменной массива (указатель на первый элемент). Тогда вы можете пойти Array.arr[i] чтобы получить i-й элемент и использовать Array.size чтобы получить количество элементов в массиве.
Я включил некоторый код для вас. Это не очень полезно, но вы можете расширить его с помощью дополнительных функций. Честно говоря, если вы хотите именно этого, вам следует прекратить использовать C и использовать другой язык со встроенными функциями.
/* Absolutely no one should use this...
By the time you're done implementing it you'll wish you just passed around
an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and
cut out the array in main by using the stdlib memory allocation methods,
but it will work much slower since it will store your array on the heap */
#include <stdio.h>
#include <string.h>
/*
#include "MyTypeArray.h"
*/
/* MyTypeArray.h
#ifndef MYTYPE_ARRAY
#define MYTYPE_ARRAY
*/
typedef struct MyType
{
int age;
char name[20];
} MyType;
typedef struct MyTypeArray
{
int size;
MyType *arr;
} MyTypeArray;
MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*
#endif
End MyTypeArray.h */
/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
MyType d;
d.age = age;
strcpy(d.name, name);
return d;
}
MyTypeArray new_MyTypeArray(int size, MyType *first)
{
MyTypeArray d;
d.size = size;
d.arr = first;
return d;
}
/* End MyTypeArray.c */
void print_MyType_names(MyTypeArray d)
{
int i;
for (i = 0; i < d.size; i++)
{
printf("Name: %s, Age: %d\n", d.arr[i].name, d.arr[i].age);
}
}
int main()
{
/* First create an array on the stack to store our elements in.
Note we could create an empty array with a size instead and
set the elements later. */
MyType arr[] = {new_MyType(10, "Sam"), new_MyType(3, "Baxter")};
/* Now create a "MyTypeArray" which will use the array we just
created internally. Really it will just store the value of the pointer
"arr". Here we are manually setting the size. You can use the sizeof
trick here instead if you're sure it will work with your compiler. */
MyTypeArray array = new_MyTypeArray(2, arr);
/* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
print_MyType_names(array);
return 0;
}
Лучше всего сохранить эту информацию, например, в структуре:
typedef struct {
int *array;
int elements;
} list_s;
Реализуйте все необходимые функции, такие как создание, уничтожение, проверка равенства и все остальное, что вам нужно. Проще передать в качестве параметра.
Функция sizeof возвращает количество байтов, которое используется вашим массивом в памяти. Если вы хотите рассчитать количество элементов в вашем массиве, вы должны разделить это число на sizeof тип переменной массива. Скажем int array[10];, если переменная типа integer на вашем компьютере является 32-битной (или 4-байтовой), чтобы получить размер вашего массива, вы должны сделать следующее:
int array[10];
int sizeOfArray = sizeof(array)/sizeof(int);
@ Magnus: стандарт определяет sizeof как число байтов в объекте, а sizeof (char) всегда равен единице. Количество битов в байте зависит от конкретной реализации.
Изменить: стандартный раздел ANSI C++ 5.3.3 Размер:
Оператор sizeof возвращает количество байтов в объектном представлении своего операнда. [...] sizeof (char), sizeof (char со знаком) и sizeof (char без знака) равны 1; результат sizeof, примененного к любому другому фундаментальному типу, определяется реализацией.
Раздел 1.6 Модель памяти C++:
Фундаментальным хранилищем в модели памяти C++ является байт. Байт, по крайней мере, достаточно большой, чтобы содержать любой элемент базового набора символов выполнения, и состоит из непрерывной последовательности битов, число которых определяется реализацией.
Вы можете использовать & оператор. Вот исходный код:
#include<stdio.h>
#include<stdlib.h>
int main(){
int a[10];
int *p;
printf("%p\n", (void *)a);
printf("%p\n", (void *)(&a+1));
printf("---- diff----\n");
printf("%zu\n", sizeof(a[0]));
printf("The size of array a is %zu\n", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));
return 0;
};
Вот пример вывода
1549216672
1549216712
---- diff----
4
The size of array a is 10
Более элегантным решением будет
size_t size = sizeof(a) / sizeof(*a);
@Skizz: Я почти уверен, что я прав, хотя лучший "источник", который я могу вам дать на данный момент, - это Википедия из статьи о sizeof:
Википедия не права, Скизз прав. sizeof(char) равен 1 по определению.
Я имею в виду, просто внимательно прочитайте статью в Википедии, чтобы понять, что это неправильно. "кратные чар". sizeof(char) никогда не может быть ничего, кроме "1". Если бы это было, скажем, 2, это означало бы, что sizeof(char) был в два раза больше символа!
Самый простой ответ:
#include <stdio.h>
int main(void) {
int a[] = {2,3,4,5,4,5,6,78,9,91,435,4,5,76,7,34};//for Example only
int size;
size = sizeof(a)/sizeof(a[0]);//Method
printf ("size = %d",size);
return 0;
}
для предопределенного массива:
int a[]={1,2,3,4,5,6};
вычисление количества элементов в массиве:
element _count =sizeof(a) / sizeof(a[0]);
Пример
#include <stdio.h>
int main() {
int size;
scanf("%d", &size);
int array[size];
printf("%d\n", (int) (sizeof(array) / sizeof(int)));
printf("%d\n", (int) (sizeof(array) / sizeof(array[0])));
return 0;
}
#ifndef __cplusplus
/* C version */
# define ARRAY_LEN_UNSAFE(X) (sizeof(X)/sizeof(*(X)))
# define ARRAY_LEN(X) (ARRAY_LEN_UNSAFE(X) + 0 * sizeof((typeof(*(X))(*[1])[ARRAY_LEN_UNSAFE(X)]){0} - (typeof(X)**)0))
#else
/* C++ version */
template <unsigned int N> class __array_len_aux { public: template <typename T, unsigned int M> static const char (&match_only_array(T(&)[M]))[M]; };
template <> class __array_len_aux<0> { public: template <typename T> static const char (&match_only_array(T(&)))[0]; };
# define ARRAY_LEN(X) sizeof(__array_len_aux<sizeof(X)>::match_only_array(X))
#endif
/* below are verifying codes */
#include <assert.h>
void * a0[0];
void * a1[9];
void * aa0[0];
void * aa1[5][10];
void *p;
struct tt {
char x[10];
char *p;
} t;
static_assert(ARRAY_LEN(a0) == 0, "verify [0]");
static_assert(ARRAY_LEN(aa0) == 0, "verify [0][N]");
static_assert(ARRAY_LEN(a1) == 9, "verify [N]");
static_assert(ARRAY_LEN(aa1) == 5, "verify [N][M]");
static_assert(ARRAY_LEN(aa1[0]) == 10, "verify inner array of [N][M]");
static_assert(ARRAY_LEN(t.x) == 10, "verify array in struct");
//static_assert(ARRAY_LEN(p) == 0, "should parse error");
//static_assert(ARRAY_LEN(t.p) == 0, "should parse error");
Следующая версияARRAY_LENзависит только отtypeof(). C++иCверсии имеют одинаковое поведение, принимают только массивы (включая массивы нулевой длины или многомерные массивы), но отклоняют любой тип указателя.
int a[10];
int size = (*(&a+1)-a) ;
для получения более подробной информации: https://aticleworld.com/how-to-find-sizeof-array-in-cc-without-using-sizeof/ https://www.geeksforgeeks.org/how-to-find-size-of-array-in-cc-without-using-sizeof-operator/
Помимо уже предоставленных ответов, я хочу указать на особый случай использования
sizeof(a) / sizeof (a[0])
Если a является либо массивом char, unsigned char или signed char вам не нужно использовать sizeof дважды с sizeof выражение с одним операндом этих типов всегда приводит к 1.
Цитата из C18,6.5.3.4 / 4:
"Когда
sizeofприменяется к операнду, имеющему типchar,unsigned char, илиsigned char, (или его квалифицированная версия) результат1."
Таким образом, sizeof(a) / sizeof (a[0]) будет эквивалентно NUMBER OF ARRAY ELEMENTS / 1 если a это массив типа char, unsigned char или signed char. Деление на 1 является избыточным.
В этом случае вы можете просто сократить и сделать:
sizeof(a)
Например:
char a[10];
size_t length = sizeof(a);
Если вам нужны доказательства, вот ссылка на GodBolt.
Тем не менее, дивизия сохраняет безопасность, если тип значительно изменится (хотя такие случаи редки).
Чтобы узнать размер фиксированного массива, объявленного явно в коде и на который ссылается его переменная, вы можете использовать sizeof, например:int a[10]int len = sizeof(a)/sizeof(int) но обычно это бесполезно, потому что вы уже знаете ответ.
НО, если у вас есть указатель, который вы НЕ МОЖЕТЕ использовать sizeof, это дело принципа. НО... Так как массивы представлены как линейная память для пользователя, вы можете рассчитать размер, если знаете адрес последнего элемента, а если знаете размер типа, то можете посчитать, сколько в нем элементов. Например:
#include <stdio.h>
int main(){
int a[10];
printf("%d\n", sizeof(a)/sizeof(int));
int *first=a;
int *last=&(a[9]);
printf("%d\n", (last-first)+1);
}
Выход:
10
10
Также, если вы не можете воспользоваться временем компиляции, вы можете:
#include <stdio.h>
int main(){
int a[10];
printf("%d\n", sizeof(a)/sizeof(int));
void *first=a;
void *last=&(a[9]);
printf("%d\n", (last-first)/sizeof(int)+1);
}
Использование:
int a=[10] = {1, 2, 3, 4, 5};
int n = sizeof(a);
printf("%d", n);
Выход:
5
Причина: вычисляет количество элементов в массиве, а не количество свободных мест, выделенных для него.