Как найти длину массива?

Есть ли способ узнать, сколько значений имеет массив? Обнаружение того, достигло ли я конца массива, также будет работать.

Если вы имеете в виду массив C-стиля, вы можете сделать что-то вроде:

int a[7]; std::cout << "Length of array = " << (sizeof(a)/sizeof(*a)) << std::endl; 

Однако это не работает с указателями, то есть оно не будет работать ни для одного из следующих:

 int *p = new int[7]; std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl; 

или:

 void func(int *p) { std::cout << "Length of array = " << (sizeof(p)/sizeof(*p)) << std::endl; } int a[7]; func(a); 

В C ++, если вы хотите такого поведения, то вы должны использовать class контейнера; вероятно, std::vector .

Как говорили другие, вы можете использовать sizeof(arr)/sizeof(*arr) но это даст вам неправильный ответ для типов указателей, которые не являются массивами.

 template constexpr size_t size(T (&)[N]) { return N; } 

У этого есть приятное свойство неспособности скомпилировать для типов без массива (визуальная студия имеет _countof которая делает это). constexpr делает это выражение времени компиляции, поэтому у него нет недостатков над макросом (по крайней мере, я не знаю).

Вы также можете использовать std::array из C ++ 11, который предоставляет свою длину без накладных расходов над собственным массивом C.

C ++ 17 имеет std::size() в заголовке который делает то же самое и работает и для контейнеров STL (благодаря @Jon C ).

Выполнение sizeof( myArray ) даст вам общее количество байтов, выделенных для этого массива. Затем вы можете узнать количество элементов в массиве, разделив на размер одного элемента в массиве: sizeof( myArray[0] )

Есть ли способ узнать, сколько значений имеет массив?

Да!

Попробуйте sizeof(array)/sizeof(array[0])

Обнаружение того, достигло ли я конца массива, также будет работать.

Я не вижу никакого способа для этого, если ваш массив не является массивом символов (т.е. строки).

PS: В C ++ всегда используйте std::vector . Существует несколько встроенных функций и расширенная функциональность.

Хотя это старый вопрос, стоит обновить ответ на C ++ 17. В стандартной библиотеке теперь есть шаблонная функция std::size() , которая возвращает количество элементов как в std-контейнере, так и в массиве C-стиля. Например:

 #include  uint32_t data[] = {10, 20, 30, 40}; auto dataSize = std::size(data); // dataSize == 4 

std::vector имеет метод size() который возвращает количество элементов в векторе.

(Да, это ответ в ответ)

 #include  int main () { using namespace std; int arr[] = {2, 7, 1, 111}; auto array_length = end(arr) - begin(arr); cout << "Length of array: " << array_length << endl; } 

Начиная с C ++ 11, появляются новые шаблоны, которые помогают уменьшить боль при работе с длиной массива. Все они определены в заголовке .

  • std::rank::value

    Если T – тип массива, значение константы члена равно числу измерений массива. Для любого другого типа значение равно 0.

  • std::extent::value

    Если T является типом массива, он предоставляет значение константы элемента, равное количеству элементов вдоль N го измерения массива, если N находится в [0, std::rank::value ). Для любого другого типа, или если T – массив неизвестных границ по его первому размеру, а N – 0, значение равно 0.

  • std::remove_extent::type

    Если T является массивом некоторого типа X , он предоставляет тип typedef члена, равный X , иначе тип – T Заметим, что если T – multidimensional array, удаляется только первое измерение.

  • std::remove_all_extents::type

    Если T является многомерным массивом некоторого типа X , он предоставляет тип typedef члена, равный X , иначе тип – T

Чтобы получить длину в любом измерении многомерного массива, decltype можно использовать для объединения с std::extent . Например:

 #include  #include  // std::remove_extent std::remove_all_extents std::rank std::extent template constexpr size_t length(T(&)[N]) { return N; } template constexpr size_t length2(T(&arr)[N]) { return sizeof(arr) / sizeof(*arr); } int main() { int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}}; // New way constexpr auto l1 = std::extent::value; // 5 constexpr auto l2 = std::extent::value; // 4 constexpr auto l3 = std::extent::value; // 3 constexpr auto l4 = std::extent::value; // 0 // Mixed way constexpr auto la = length(a); //constexpr auto lpa = length(*a); // compile error //auto lpa = length(*a); // get at runtime std::remove_extent::type pa; // get at compile time //std::remove_reference::type pa; // same as above constexpr auto lpa = length(pa); std::cout << la << ' ' << lpa << '\n'; // Old way constexpr auto la2 = sizeof(a) / sizeof(*a); constexpr auto lpa2 = sizeof(*a) / sizeof(**a); std::cout << la2 << ' ' << lpa2 << '\n'; return 0; } 

BTY, чтобы получить общее количество элементов в многомерном массиве:

 constexpr auto l = sizeof(a) / sizeof(std::remove_all_extents::type); 

Или поместите его в шаблон функции:

 #include  #include  template constexpr size_t len(T &a) { return sizeof(a) / sizeof(typename std::remove_all_extents::type); } int main() { int a[5][4][3]{{{1,2,3}, {4,5,6}}, { }, {{7,8,9}}}; constexpr auto ttt = len(a); int i; std::cout << ttt << ' ' << len(i) << '\n'; return 0; } 

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

Также есть способ TR1 / C ++ 11 / C ++ 17 (см. « Live on Coliru» ):

 const std::string s[3] = { "1"s, "2"s, "3"s }; constexpr auto n = std::extent< decltype(s) >::value; // From  constexpr auto n2 = std::extent_v< decltype(s) >; // C++17 shorthand const auto a = std::array{ "1"s, "2"s, "3"s }; // C++17 class template arg deduction -- http://en.cppreference.com/w/cpp/language/class_template_argument_deduction constexpr auto size = std::tuple_size_v< decltype(a) >; std::cout << n << " " << n2 << " " << size << "\n"; // Prints 3 3 3 

Вместо использования встроенной функции массива aka:

  int x[2] = {0,1,2}; 

вы должны использовать class массива и шаблон массива. Пытаться:

 #include  array Name_of_Array = {}; 

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

 Name_of_Array.size(); 

и это должно возвращать длину элементов в массиве.

В C ++, используя class std :: array для объявления массива, можно легко найти размер массива, а также последний элемент.

 #include #include int main() { std::array arr; //To find the size of the array std::cout< 

Фактически, class массива имеет множество других функций, которые позволяют использовать массив стандартным контейнером.
Ссылка 1 на C ++ std :: class массива
Ссылка 2 на class std :: array
Примеры в ссылках полезны.

Вот одна реализация ArraySize от Google Protobuf .

 #define GOOGLE_ARRAYSIZE(a) \ ((sizeof(a) / sizeof(*(a))) / static_cast(!(sizeof(a) % sizeof(*(a))))) // test codes... char* ptr[] = { "you", "are", "here" }; int testarr[] = {1, 2, 3, 4}; cout << GOOGLE_ARRAYSIZE(testarr) << endl; cout << GOOGLE_ARRAYSIZE(ptr) << endl; 

ARRAYSIZE (arr) работает, проверяя sizeof (arr) (количество байтов в массиве) и sizeof (* (arr)) (количество байтов в одном элементе массива). Если первое делится на последнее, возможно, arr действительно является массивом, и в этом случае результатом деления является # элементов в массиве. В противном случае arr не может быть массивом, и мы генерируем ошибку компилятора, чтобы предотвратить компиляцию кода.

Поскольку размер bool определяется реализацией, нам нужно отличать! (Sizeof (a) & sizeof (* (a))) до size_t, чтобы гарантировать, что конечный результат имеет тип size_t.

Этот макрос не идеален, поскольку он ошибочно принимает определенные указатели, а именно, где размер указателя делится на размер точки. Поскольку весь наш код должен проходить через 32-битный компилятор, где указатель имеет 4 байта, это означает, что все указатели на тип, размер которого равен 3 или больше 4, будут (праведно) отклонены.

Для C ++ / CX (при написании, например, приложений UWP с использованием C ++ в Visual Studio) мы можем найти количество значений в массиве, просто используя функцию size() .

Исходный код:

 string myArray[] = { "Example1", "Example2", "Example3", "Example4" }; int size_of_array=size(myArray); 

Если вы size_of_array вывод будет:

 >>> 4 

Хорошее решение, использующее дженерики:

 template  inline unsigned arraysize(const T (&v)[S]) { return S; } 

Затем просто вызовите arraysize(_Array); чтобы получить длину массива.

Источник

  length = sizeof(array_name)/sizeof(int); 

Просто подумал, но просто решил создать переменную счетчика и сохранить размер массива в позиции [0]. Я удалил большую часть кода, который у меня был в функции, но вы увидите после выхода из цикла, prime [0] получает окончательное значение «a». Я пробовал использовать векторы, но VS Express 2013 не очень понравился. Также обратите внимание, что «a» начинается с одного, чтобы избежать перезаписи [0], и вначале он инициализировался, чтобы избежать ошибок. Я не эксперт, просто подумал, что поделюсь.

 int prime[] = {0}; int primes(int x, int y){ using namespace std; int a = 1; for (int i = x; i <= y; i++){prime[a] = i; a++; } prime[0] = a; return 0; } 

Одной из наиболее распространенных причин, по которым вы в конечном итоге это искали, является то, что вы хотите передать массив функции, и не должны передавать другой аргумент для его размера. Вам также в целом понравится, чтобы размер массива был динамическим. Этот массив может содержать объекты, а не примитивы, а объекты могут быть сложными, так что size_of () является небезопасным вариантом для вычисления счетчика.

Как и другие, предложите использовать std :: vector или list и т. Д. Вместо примитивного массива. Однако для старых компиляторов у вас все равно не будет окончательного решения, которое вы, вероятно, захотите, просто сделав это, потому что для заполнения контейнера требуется куча уродливых строк push_back (). Если вы похожи на меня, вам нужно однолинейное решение с анонимными объектами.

Если вы идете с контейнером STL, альтернативным примитивному массиву, это сообщение SO может быть полезно вам для путей его инициализации: что является самым простым способом инициализации std :: vector с жестко закодированными элементами?

Вот метод, который я использую для этого, который будет работать повсеместно по всем компиляторам и платформам:

Создайте структуру или class как контейнер для вашей коллекции объектов. Определите функцию перегрузки оператора для <<.

 class MyObject; struct MyObjectList { std::list objects; MyObjectList& operator<<( const MyObject o ) { objects.push_back( o ); return *this; } }; 

Вы можете создавать функции, которые принимают вашу структуру как параметр, например:

 someFunc( MyObjectList &objects ); 

Затем вы можете вызвать эту функцию, например:

 someFunc( MyObjectList() << MyObject(1) << MyObject(2) << MyObject(3) ); 

Таким образом, вы можете создавать и передавать коллекции объектов с динамическим размером в одну единственную чистую строку!

Избегайте использования типа вместе с sizeof, поскольку sizeof(array)/sizeof(char) внезапно становится поврежденным, если вы изменяете тип массива.

В visual studio у вас есть эквива лентный if sizeof(array)/sizeof(*array) . Вы можете просто набрать _countof(array)

Для старого компилятора g ++ вы можете сделать это

 template  char (&helper(T (&)[N]))[N]; #define arraysize(array) (sizeof(helper(array))) int main() { int a[10]; std::cout << arraysize(a) << std::endl; return 0; } 

Я лично предложил бы (если вы не можете работать со специализированными функциями по любой причине), чтобы сначала расширить совместимость типов массивов с тем, что вы обычно использовали бы как (если бы вы сохраняли значения ≥ 0:

 unsigned int x[] -> int x[] 

чем вы сделаете элемент массива 1 больше, чем вам нужно. Для последнего элемента вы бы поместили некоторый тип, который включен в расширенный спецификатор типа, но который вы обычно не используете, например, используя предыдущий пример, последний элемент будет равен -1. Это позволяет вам (используя цикл for) найти последний элемент массива.

Я предлагаю здесь сложное решение:

Вы всегда можете сохранить length в первом элементе:

 // malloc/new arr[0] = length; arr++; // do anything. int len = *(arr-1); free(--arr); 

Стоимость вы должны --arr при вызове free

Допустим, у вас есть глобальный массив, объявленный в верхней части страницы

 int global[] = { 1, 2, 3, 4 }; 

Чтобы узнать, сколько элементов есть (в c ++) в массиве, введите следующий код:

 sizeof(global) / 4; 

Sizeof (NAME_OF_ARRAY) / 4 вернет вам количество элементов для данного имени массива.

  • Как обновить несколько элементов массива в mongodb
  • Передача массива по ссылке в C?
  • Класс Java Comparator для сортировки массивов
  • Как узнать, содержит ли массив строку
  • Как преобразовать массив символов в строку?
  • Почему я не могу создать массив с размером, определяемым глобальной переменной?
  • Передача многомерного массива переменной длины в функцию
  • Ожидаемое постоянное выражение C ++
  • Добавление элементов в массив Swift для нескольких streamов, вызывающих проблемы (поскольку массивы не являются streamобезопасными) - как мне обойти это?
  • Объединение двух массивов в .NET.
  • Может ли Java-массив использоваться как ключ HashMap
  • Interesting Posts

    Что ограничивает скорость WiFi?

    Каково максимальное количество байтов для кодированного символа UTF-8?

    В чем разница между статически типизированными и динамически типизированными языками?

    имя classа jquery change

    Как работает WOL (Wake-On LAN)?

    Как использовать PrimeFaces p: fileUpload? Метод прослушивателя никогда не вызывается или UploadedFile имеет значение null / выбрасывает ошибку / не используется

    Поведение MySQL «выберите для обновления»

    Как я могу освободить место на диске из папки установщика Windows, не убивая Windows?

    Различия между инициализацией, определением, объявлением переменной

    Маржа, сжимающаяся в flexbox

    Последний в родительском селекторе CSS

    Параметры настроек приложения не отображаются в результатах поиска на win10

    Какая правильная альтернатива статическому наследованию метода?

    Черта для числовой функциональности в Rust

    Как я могу остановить jQuery mobile для применения стилей к моим конкретным элементам формы

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