Как определить длину массива в C++
По сути, когда мы говорим о длине массива, мы имеем в виду общее количество элементов, присутствующих в соответствующем массиве. Например, посмотрите на массив ниже:
Размер (или длина) массива равна общему количеству элементов в нем. Следовательно, в данном случае это «5».
Способы определения длины массива в C++
Теперь давайте посмотрим на различные способы, с помощью которых мы можем выяснить длину массива в C++:
- поэлементный подсчет,
- begin() и end(),
- функция sizeof(),
- функция size() в STL,
- указатели.
Теперь давайте обсудим каждый метод подробно и с примерами.
1: Поэлементный подсчет
Самый очевидный способ – перебрать заданный массив и одновременно подсчитать общее количество перебранных элементов.
Но если мы заранее не знаем длину массива для итерации, то в таком случае мы не можем использовать цикл for. Эту проблему можно решить, используя простой цикл for-each. Внимательно посмотрите на приведенный ниже код.
Вы получите такой результат:
Как мы говорили выше, здесь мы перебираем весь массив arr, используя цикл for-each с итератором i. Значение счетчика c увеличивается по мере итерации. Когда перебор закончится, в c вы найдете длину данного массива.
2: Функции begin() и end()
Мы также можем вычислить длину массива, используя стандартные функции begin() и end(). Эти две функции возвращают итераторы, указывающие на начало и конец массива соответственно. Внимательно посмотрите на данный код:
Следовательно, разница между возвращаемыми значениями двух функций end() и begin() дает нам размер или длину данного массива. Данный код вернет:
3: Функция sizeof()
Оператор sizeof() в C++ возвращает размер переданной переменной или данных в байтах. Кроме того, он возвращает общее количество байтов, необходимых для хранения массива. Следовательно, если мы просто разделим размер массива на размер, занимаемый каждым его элементом, мы узнаем общее количество элементов, присутствующих в массиве.
Давайте посмотрим, как это работает:
В результате мы получим:
4: Функция size() в STL
В стандартной библиотеке есть функция size(), которая возвращает количество элементов в заданном контейнере (в нашем случае это массив).
В результате вы получите:
5: Определение длины массива с помощью указателей
Узнать длину массива можно с помощью указателей. Давайте посмотрим, как это делается:
В результате мы получим:
Выражение *(arr+1) выдает адрес области памяти сразу после последнего элемента массива. Следовательно, разница между ним и начальным местоположением массива (или базовым адресом, arr) показывает общее количество элементов, присутствующих в данном массиве.
Заключение
Итак, в этом мануале мы обсудили различные методы определения длины массива в C++. Все приведенные выше методы просты в использовании, однако мы предпочитаем применять цикл for-each – не только из-за удобочитаемости кода, но и из-за его кросс-платформенной надежности.
Найдите размер массива в C, используя оператор sizeof и арифметику указателя
В этом посте представлен обзор некоторых доступных альтернатив для определения размера массива в C.
1. оператор sizeof
Стандартным способом является использование sizeof оператор, чтобы найти размер массива в стиле C. sizeof Оператор над массивом возвращает общую память, занимаемую массивом, в байтах. Чтобы определить общее количество элементов массива, трюк состоит в том, чтобы разделить общую память, занимаемую массивом, на размер каждого элемента. Это показано ниже на языке C:
Для простоты и улучшения читаемости кода предлагается сконструировать из него МАКРОС, как показано ниже:
Мы знаем, что массив распадается на указатель при передаче функции в качестве аргумента независимо от того, объявлен ли параметр как int[] или нет. Таким образом, описанный выше подход работает только со статическими массивами, но не работает с динамически выделенными массивами и параметрами функций, поскольку они оба включают указатели.
2. Использование арифметики указателей
Хитрость заключается в использовании выражения (&arr)[1] — arr чтобы получить массив arr размер. Оба arr а также &arr указывает на одну и ту же ячейку памяти, но они оба имеют разные типы.
- arr имеет тип int* и распадается на указатель на первый элемент массива. Следовательно, любые знания о размере массива исчезли.
- &arr приводит к указателю типа int (*)[n] , то есть указатель на массив n целые Так, &arr указывает на весь массив и *(&arr + 1) (или же &arr)[1] ) указывает на следующий байт после массива.
Это работает благодаря тому, как работает арифметика указателей в C. Мы знаем, что указатель на int продвигается sizeof(int) при увеличении на 1. Точно так же указатель на int[n] продвигается sizeof(int[n]) , что является размером всего массива.
Как узнать размер массива c
Массив представляет набор однотипных данных. Объявление массива похоже на объявление переменной за тем исключением, что после указания типа ставятся квадратные скобки:
Например, определим массив целых чисел:
После определения переменной массива мы можем присвоить ей определенное значение:
Здесь вначале мы объявили массив nums, который будет хранить данные типа int . Далее используя операцию new , мы выделили память для 4 элементов массива: new int[4] . Число 4 еще называется длиной массива . При таком определении все элементы получают значение по умолчанию, которое предусмотренно для их типа. Для типа int значение по умолчанию — 0.
Также мы сразу можем указать значения для этих элементов:
Все перечисленные выше способы будут равноценны.
Подобным образом можно определять массивы и других типов, например, массив значений типа string :
Индексы и получение элементов массива
Для обращения к элементам массива используются индексы . Индекс представляет номер элемента в массиве, при этом нумерация начинается с нуля, поэтому индекс первого элемента будет равен 0, индекс четвертого элемента — 3.
Используя индексы, мы можем получить элементы массива:
Также мы можем изменить элемент массива по индексу:
И так как у нас массив определен только для 4 элементов, то мы не можем обратиться, например, к шестому элементу. Если мы так попытаемся сделать, то мы получим ошибку во время выполнения:
Свойство Length и длина массива
каждый массив имеет свойство Length , которое хранит длину массива. Например, получим длину выше созданного массива numbers:
Для получения длины массива после названия массива через точку указывается свойство Length : numbers.Length .
Получение элементов с конца массива
Благодаря наличию свойства Length , мы можем вычислить индекс последнего элемента массива — это длина массива — 1. Например, если длина массива — 4 (то есть массив имеет 4 элемента), то индекс последнего элемента будет равен 3. И, используя свойство Length , мы можем легко получить элементы с конца массива:
Однако при подобном подходе выражения типа numbers.Length — 1 , смысл которых состоит в том, чтобы получить какой-то определенный элемент с конца массива, утяжеляют код. И, начиная, с версии C# 8.0 в язык был добавлен специальный оператор ^ , с помощью которого можно задать индекс относительно конца коллекции.
Перепишем предыдущий пример, применяя оператор ^ :
Перебор массивов
Для перебора массивов мы можем использовать различные типы циклов. Например, цикл foreach :
Здесь в качестве контейнера выступает массив данных типа int . Поэтому мы объявляем переменную с типом int
Подобные действия мы можем сделать и с помощью цикл for:
В то же время цикл for более гибкий по сравнению с foreach . Если foreach последовательно извлекает элементы контейнера и только для чтения, то в цикле for мы можем перескакивать на несколько элементов вперед в зависимости от приращения счетчика, а также можем изменять элементы:
Также можно использовать и другие виды циклов, например, while :
Многомерные массивы
Массивы характеризуются таким понятием как ранг или количество измерений. Выше мы рассматривали массивы, которые имеют одно измерение (то есть их ранг равен 1) — такие массивы можно представлять в виде ряда (строки или столбца) элемента. Но массивы также бывают многомерными. У таких массивов количество измерений (то есть ранг) больше 1.
Массивы которые имеют два измерения (ранг равен 2) называют двухмерными. Например, создадим одномерный и двухмерный массивы, которые имеют одинаковые элементы:
How do I determine the size of my array in C?
To determine the size of your array in bytes, you can use the sizeof operator:
On my computer, ints are 4 bytes long, so n is 68.
To determine the number of elements in the array, we can divide the total size of the array by the size of the array element. You could do this with the type, like this:
and get the proper answer (68 / 4 = 17), but if the type of a changed you would have a nasty bug if you forgot to change the sizeof(int) as well.
So the preferred divisor is sizeof(a[0]) or the equivalent sizeof(*a) , the size of the first element of the array.
Another advantage is that you can now easily parameterize the array name in a macro and get:
The sizeof way is the right way iff you are dealing with arrays not received as parameters. An array sent as a parameter to a function is treated as a pointer, so sizeof will return the pointer’s size, instead of the array’s.
Thus, inside functions this method does not work. Instead, always pass an additional parameter size_t size indicating the number of elements in the array.
Output (in a 64-bit Linux OS):
Output (in a 32-bit windows OS):
It is worth noting that sizeof doesn’t help when dealing with an array value that has decayed to a pointer: even though it points to the start of an array, to the compiler it is the same as a pointer to a single element of that array. A pointer does not «remember» anything else about the array that was used to initialize it.
The sizeof "trick" is the best way I know, with one small but (to me, this being a major pet peeve) important change in the use of parenthesis.
As the Wikipedia entry makes clear, C’s sizeof is not a function; it’s an operator. Thus, it does not require parenthesis around its argument, unless the argument is a type name. This is easy to remember, since it makes the argument look like a cast expression, which also uses parenthesis.
So: If you have the following:
You can find the number of elements with code like this:
That, to me, reads a lot easier than the alternative with parenthesis. I also favor use of the asterisk in the right-hand part of the division, since it’s more concise than indexing.
Of course, this is all compile-time too, so there’s no need to worry about the division affecting the performance of the program. So use this form wherever you can.
It is always best to use sizeof on an actual object when you have one, rather than on a type, since then you don’t need to worry about making an error and stating the wrong type.
For instance, say you have a function that outputs some data as a stream of bytes, for instance across a network. Let’s call the function send() , and make it take as arguments a pointer to the object to send, and the number of bytes in the object. So, the prototype becomes:
And then you need to send an integer, so you code it up like this:
Now, you’ve introduced a subtle way of shooting yourself in the foot, by specifying the type of foo in two places. If one changes but the other doesn’t, the code breaks. Thus, always do it like this:
Now you’re protected. Sure, you duplicate the name of the variable, but that has a high probability of breaking in a way the compiler can detect, if you change it.