Как найти размер int []?

У меня есть

int list[] = {1, 2, 3};

Как мне получить размер list?

Я знаю, что для массива символов мы можем использовать strlen(array), чтобы найти размер, или проверить с помощью '\0' в конце массива.

Я попытался sizeof(array) / sizeof(array[0]), как сказали некоторые ответы, но он работает только в основном? Например:

int size(int arr1[]){
    return sizeof(arr1) / sizeof(arr1[0]);
}

int main() {
    int list[] = {1, 2, 3};

    int size1 = sizeof(list) / sizeof(list[0]); // ok
    int size2 = size(list_1); // no
    // size1 and size2 are not the same
}

Почему?

ОТВЕТЫ

Ответ 1

Попробуйте это:

sizeof(list) / sizeof(list[0]);

Поскольку этот вопрос помечен C++, всегда рекомендуется использовать std::vector в C++, а не использовать обычные массивы в стиле C.

array-type неявно преобразуется в pointer-type при передаче его функции. Посмотрите на это.

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

Вы бы сделали это так для общего случая

template<typename T,int N> 
//template argument deduction
int size(T (&arr1)[N]) //Passing the array by reference 
{
   return sizeof(arr1)/sizeof(arr1[0]); //Correctly returns the size of 'list'
   // or
   return N; //Correctly returns the size too [cool trick ;-)]
}

Ответ 2

"Стандартный" способ C это сделать

sizeof(list) / sizeof(list[0])

Ответ 3

Вы можете использовать boost::size, который в основном определяется следующим образом:

template <typename T, std::size_t N>
std::size_t size(T const (&)[N])
{
    return N;
}

Обратите внимание, что если вы хотите использовать размер как константное выражение, вам придется либо использовать idiom sizeof a / sizeof a[0], либо ждать следующей версии стандарта С++.

Ответ 4

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

#define COUNTOF(x) (sizeof(x)/sizeof(*x))

Чтобы получить размер динамического массива, вы должны отслеживать его вручную и передавать его с ним или завершать его с помощью значения контрольной суммы (например, "\ 0" в нулевых завершенных строках).

Обновление: Я понял, что ваш вопрос отмечен как С++, а не C. Вам обязательно нужно использовать std::vector вместо массивов на С++, если вы хотите обойти вокруг:

std::vector<int> v;
v.push_back(1);
v.push_back(2);
std::cout << v.size() << std::endl; // prints 2

Ответ 5

Поскольку вы отметили это как С++, стоит упомянуть, что есть несколько лучший способ, чем макрос C-стиля:

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

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

int a[20];

char x[countof(a)];

В С++ 11 или новее вы можете добавить constexpr, чтобы получить константу времени компиляции:

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

Если вы действительно хотите поддерживать то же самое на старых компиляторах, существует способ, первоначально изобретенный Иваном Джонсоном, AFAIK:

#define COUNTOF(x)  (                                           \
  0 * sizeof( reinterpret_cast<const ::Bad_arg_to_COUNTOF*>(x) ) +  \
  0 * sizeof( ::Bad_arg_to_COUNTOF::check_type((x), &(x))      ) +  \
  sizeof(x) / sizeof((x)[0])  )                                  


class Bad_arg_to_COUNTOF
{
public:
   class Is_pointer;
   class Is_array {};  
   template<typename T>
   static Is_pointer check_type(const T*, const T* const*);
   static Is_array check_type(const void*, const void*);
};

Для вычисления размера используется sizeof (x)/sizeof (x [0]), как и макрос C, поэтому он дает константу времени компиляции. Разница в том, что он сначала использует магию шаблона, чтобы вызвать ошибку компиляции, если то, что вы передали, не является именем массива. Он делает это, перегружая check_type, чтобы вернуть неполный тип для указателя, но полный тип для массива. Затем (действительно сложная часть) она фактически не вызывает эту функцию вообще - она ​​просто принимает размер типа, возвращаемого функцией, которая равна нулю для перегрузки, которая возвращает полный тип, но не разрешена (принудительная ошибка компиляции) для неполного типа.

IMO, это довольно классный пример метапрограмм шаблонов - хотя, честно говоря, результат не имеет смысла. Вам действительно нужен только этот размер как постоянная времени компиляции, если вы используете массивы, которых вы обычно должны избегать в любом случае. Используя std::vector, это прекрасно, чтобы обеспечить размер во время выполнения (и изменить размер вектора при необходимости).

Ответ 6

Помимо ответа Carl, "стандартный" С++ способ заключается не в использовании массива C int, а скорее как С++ STL std::vector<int> list, который вы можете запросить для list.size().

Ответ 7

когда u передает любой массив некоторой функции. u просто передают его начальный адрес, поэтому для его работы вам нужно передать его размер и для его правильной работы. это та же самая причина, по которой мы передаем argc с argv [] в аргументе командной строки.

Ответ 8

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

Вот мой фрагмент кода

template <typename TypeOfData>


void PrintArray(TypeOfData &arrayOfType);

int main()

{

    char charArray[] = "my name is";

    int intArray[] = { 1,2,3,4,5,6 };

    double doubleArray[] = { 1.1,2.2,3.3 };


    PrintArray(charArray);

    PrintArray(intArray);

    PrintArray(doubleArray);

}


template <typename TypeOfData>

void PrintArray(TypeOfData &arrayOfType)

{

    int elementsCount = sizeof(arrayOfType) / sizeof(arrayOfType[0]);


    for (int i = 0; i < elementsCount; i++)

    {

        cout << "Value in elements at position " << i + 1 << " is " << arrayOfType[i] << endl;

    }

}

Ответ 9

Вы должны использовать функцию sizeof().

Фрагмент кода:

#include<bits/stdc++.h>
using namespace std;

int main()
{
      ios::sync_with_stdio(false);

      int arr[] ={5, 3, 6, 7};

      int size = sizeof(arr) / sizeof(arr[0]);
      cout<<size<<endl;

      return 0;
}

Ответ 10

int arr1[] = {8, 15, 3, 7};
int n = sizeof(arr1)/sizeof(arr1[0]);

Таким образом, в основном sizeof (arr1) задает размер объекта, на который указывает указатель, каждый элемент может занимать несколько битов, поэтому деление на количество бит на элемент (sizeof (arr1 [0]) дает фактическое количество элементов вы ищете, т.е. 4 в моем примере.

Ответ 11

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

template <typename T, size_t n, size_t m>   
Matrix& operator= (T (&a)[n][m])
{   

    int arows = n;
    int acols = m;

    p = new double*[arows];

    for (register int r = 0; r < arows; r++)
    {
        p[r] = new double[acols];


        for (register int c = 0; c < acols; c++)
        {
            p[r][c] = a[r][c]; //A[rows][columns]
        }

}

https://www.geeksforgeeks.org/how-to-print-size-of-an-array-in-a-function-in-c/

Ответ 12

Если вы хотите узнать, сколько чисел имеет массив, вы хотите узнать длину массива. Функция sizeof (var) в C дает вам байты в памяти компьютера. Поэтому, если вы знаете, какую память занимает int, вы можете сделать это следующим образом:

int arraylength(int array[]) {
    return sizeof(array) / 4; // Size of the Array divided by the int size which is 4
}