Как найти сколько элементов в массиве

The question is simple: given a C++ array (e.g. x as in int x[10]), how would you get the number of elements in it?

An obvious solution is the following macro (definition 1):

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

I cannot say this isn’t correct, because it does give the right answer when you give it an array. However, the same expression gives you something bogus when you supply something that is not an array. For example, if you have

int * p;

then countof( p ) always give you 1 on a machine where an int pointer and an int have the same size (e.g. on a Win32 platform).

This macro also wrongfully accepts any object of a class that has a member function operator[]. For example, suppose you write

class IntArray {
private:
    int * p;
    size_t size;
public:
    int & operator [] ( size_t i );
} x;

then sizeof( x ) will be the size of the x object, not the size of the buffer pointed to by x.p. Therefore you won’t get a correct answer by countof( x ).

So we conclude that definition 1 is not good because the compiler does not prevent you from misusing it. It fails to enforce that only an array can be passed in.

What is a better option?

Well, if we want the compiler to ensure that the parameter to countof is always an array, we have to find a context where only an array is allowed. The same context should reject any non-array expression.

Some beginners may try this (definition 2):

template <typename T, size_t N>
size_t countof( T array[N] )
{
   return N;
}

They figure, this template function will accept an array of N elements and return N.

Unfortunately, this doesn’t compile because C++ treats an array parameter the same as a pointer parameter, i.e. the above definition is equivalent to:

template <typename T, size_t N>
size_t countof( T * array )
{
    return N;
}

It now becomes obvious that the function body has no way of knowing what N is.

However, if a function expects an array reference, then the compiler does make sure that the size of the actual parameter matches the declaration. This means we can make definition 2 work with a minor modification (definition 3):

template <typename T, size_t N>
size_t countof( T (&array)[N] )
{
    return N;
}

This countof works very well and you cannot fool it by giving it a pointer. However, it is a function, not a macro. This means you cannot use it where a compile time constant is expected. In particular, you cannot write something like:

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

Can we do anything about it?

Someone (I don’t know who it is – I just saw it in a piece of code from an unknown author) came up with a clever idea: moving N from the body of the function to the return type (e.g. make the function return an array of N elements), then we can get the value of N without actually calling the function.

To be precise, we have to make the function return an array reference, as C++ does not allow you to return an array directly.

The implementation of this is:

template <typename T, size_t N>
char ( &_ArraySizeHelper( T (&array)[N] ))[N];

#define countof( array ) (sizeof( _ArraySizeHelper( array ) ))

Admittedly, the syntax looks awful. Indeed, some explanation is necessary.

First, the top-level stuff

char ( &_ArraySizeHelper( ... ))[N];

says _ArraySizeHelper is a function that returns a reference (note the &) to a char array of N elements.

Next, the function parameter is

T (&array)[N]

which is a reference to a T array of N elements.

Finally, countof is defined as the size of the result of the function _ArraySizeHelper. Note we don’t even need to define _ArraySizeHelper(), — a declaration is enough.

With this new definition,

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

becomes valid, just as we desire.

Am I happy now? Well, I think this definition is definitely better than the others we have visited, but it is still not quite what I want. For one thing, it doesn’t work with types defined inside a function. That’s because the template function _ArraySizeHelper expects a type that is accessible in the global scope.

I don’t have a better solution. If you know one, please let me know.

This is pretty much old and legendary question and there are already many amazing answers out there. But with time there are new functionalities being added to the languages, so we need to keep on updating things as per new features available.

I just noticed any one hasn’t mentioned about C++20 yet. So thought to write answer.

C++20

In C++20, there is a new better way added to the standard library for finding the length of array i.e. std:ssize(). This function returns a signed value.

#include <iostream>

int main() {
    int arr[] = {1, 2, 3};
    std::cout << std::ssize(arr);
    return 0;
}

C++17

In C++17 there was a better way (at that time) for the same which is std::size() defined in iterator.

#include <iostream>
#include <iterator> // required for std::size

int main(){
    int arr[] = {1, 2, 3};
    std::cout << "Size is " << std::size(arr);
    return 0;
}

P.S. This method works for vector as well.

Old

This traditional approach is already mentioned in many other answers.

#include <iostream>

int main() {
    int array[] = { 1, 2, 3 };
    std::cout << sizeof(array) / sizeof(array[0]);
    return 0;
}

Just FYI, if you wonder why this approach doesn’t work when array is passed to another function. The reason is,

An array is not passed by value in C++, instead the pointer to array is passed. As in some cases passing the whole arrays can be expensive operation. You can test this by passing the array to some function and make some changes to array there and then print the array in main again. You’ll get updated results.

And as you would already know, the sizeof() function gives the number of bytes, so in other function it’ll return the number of bytes allocated for the pointer rather than the whole array. So this approach doesn’t work.

But I’m sure you can find a good way to do this, as per your requirement.

Happy Coding.

В этой статье мы рассмотрим, как определить количество элементов в объекте Python и при необходимости подсчитать их сумму. Также увидим, как подсчитать количество вхождений конкретного элемента.

Итак, представим, что у нас есть следующий массив:

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

В первую очередь, вспомним, что в языке программирования Python существует специальная функция, возвращающая длину списка, массива, последовательности и так далее — это len(x), где x — наша последовательность.

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

print(len(array))
6
Press any key to continue . . .


А для подсчёта суммы можем занести перечисление массива Python в цикл:
array = [6,2,7,4,8,1]
sum = 0
for i in range(len(array)):
    sum  = array[i]
print(sum)


В принципе, вопрос решён. Но, по правде говоря, перебор целочисленного массива с помощью цикла для получения суммы элементов массива — это, всё же, костыль)). Дело в том, что в Python существует встроенная функция sum(). Она вернёт нам сумму без лишних телодвижений.
def main():
    array = [1,6,3,8,4,9,25,2]
    print(sum(array))
if name == 'main':

main()
58
Press any key to continue . . .


Python: количество вхождений конкретного элемента
Бывает, нам надо подсчитать число вхождений определённых элементов в списке и вернуть найденное значение. Для этого в Python есть метод count(). Вот его синтаксис:

Метод принимает аргумент x, значение которого нас интересует. И возвращает число вхождений интересующего элемента в список:
# объявляем список
website_list = ['otus.ru','includehelp.com', 'yandex.by', 'otus.ru']

# подсчитываем вхождения 'otus.ru'
count = website_list.count('otus.ru')
print('otus.ru found',count,'times.')

# подсчитываем вхождения 'yandex.by'
count = website_list.count('yandex.by')
print('yandex.by found',count,'times.')


Итог будет следующим:
otus.ru found 2 times.
yandex.by found 1 times.


Также этот метод успешно работает и с кортежами:
# объявляем кортеж
sample_tuple = ((1,3), (2,4), (4,6))

# условные вхождения (1,2) 
count = sample_tuple.count((1,2))
print('(1,2) found',count,'times.')

# условные вхождения (1,3) 
count = sample_tuple.count((1,3))
print('(1,3) found',count,'times.')


Результат:
(1,2) found 0 times.
(1,3) found 1 times.


Вот и всё, теперь вы знаете, как подсчитывать количество элементов в списке, массиве, кортеже в Python.

Вернуться к: Функции для работы с массивами