Программно определить размер массива C++?

Обычный способ справиться с этим - использовать вектор

int main()
{
   std::vector<int> v(256);
   printf("size of v is %i capacity is %i\n", sizeof(int) * v.size(), sizeof(int) * v.capacity());
}

или заранее определите размер

const int arrSize = 256;
int main()
{
    int array[arrSize];
    printf("Size of array is %i", sizeof(int) * arrSize);
}

Это потому, что ваша переменная arr - всего лишь указатель. Он хранит адрес определенного места в памяти, ничего не зная об этом. Вы объявляете его как int *, что дает компилятору некоторое представление о том, что делать, когда вы увеличиваете указатель. Кроме того, вы могли указывать на начало или конец массива, либо в стек, либо в недопустимую память. Но я согласен с вами, отсутствие возможности вызвать sizeof очень раздражает :)

QuantumPete

Нет, нет никакого способа сделать это, вы должны следить за тем, насколько он велик внешне. Такие классы, как std::vector, делают это за вас.

Нет, в Standard C++ это невозможно.

Нет действительно веской причины, о которой я знаю. Вероятно, размер считался деталью реализации и лучше не раскрывать. Обратите внимание: когда вы говорите malloc (1000), нет гарантии, что возвращаемый блок составляет 1000 байт - только то, что это по меньшей мере 1000 байт. Скорее всего, это около 1020 (1 КБ минус 4 байта на накладные расходы). В этом случае размер «1020» является важным для запоминания библиотеки времени выполнения. И, конечно, это будет меняться между реализациями.

Вот почему комитет по стандартам добавил std: vector <>, который отслеживает его точный размер.

delete [] знает размер, который был выделен. Однако эти знания находятся во время выполнения или в диспетчере памяти операционной системы, что означает, что они недоступны для компилятора во время компиляции. И sizeof() не является реальной функцией, он фактически вычисляется компилятором как константа, чего он не может сделать для динамически выделяемых массивов, размер которых неизвестен во время компиляции.

Также рассмотрите этот пример:

int *arr = new int[256];
int *p = &arr[100];
printf("Size: %d\n", sizeof(p));

Как компилятор узнает размер p? Корень проблемы в том, что массивы в C и C++ не являются объектами первого класса. Они распадаются на указатели, и компилятор или сама программа не могут узнать, указывает ли указатель на начало блока памяти, выделенного new, или на отдельный объект, или на какое-то место в середине кусок памяти, выделенный new.

Одна из причин этого заключается в том, что C и C++ оставляют управление памятью на усмотрение программиста и операционной системы, поэтому в них также отсутствует сборка мусора. Реализация new и delete не является частью стандарта C++, поскольку C++ предназначен для использования на различных платформах, которые могут управлять своей памятью по-разному. Можно позволить C++ отслеживать все выделенные массивы и их размеры, если вы пишете текстовый процессор для окна Windows, работающего на новейшем процессоре Intel, но это может быть совершенно невозможно, когда вы пишете встроенную систему, работающую на DSP.

По сути, вы не можете:

void foo(int* arr);

int arr[100] = {0};

foo(arr+1); // Calls foo with a pointer to 100-1 elements.

Массив C++ - это не что иное, как набор объектов, которые хранятся в непрерывной области памяти. Поскольку между ними нет дыр (заполнение - это объекты внутри), вы можете найти следующий элемент массива, просто вставив указатель. На уровне ЦП это простая настройка. C++ вставляет только множитель sizeof (element).

Обратите внимание, что реализации могут выбрать реализацию «жирных указателей», которые содержат границы массива. Они должны быть вдвое больше, так как вам нужно будет ссылаться на какой-то «дескриптор, связанный с массивом». В качестве побочного эффекта в таких реализациях вы можете вызвать delete [] (1+new int[5]);

К сожалению, это невозможно. В C и C++ обязанность программиста - помнить о длине массива, поскольку длина массива нигде не хранится. Delete [] и free () запоминают размер выделенного блока, но они могут выделить больше памяти, чем запрошено, поэтому их внутренние структуры данных, хранящие размеры выделенных блоков памяти, могут не дать вам точного размера вашего массива.

Обратите внимание, что векторы C++ STL, которые в основном представляют собой массивы, обернутые в класс с некоторыми вспомогательными функциями, действительно хранят длину массива, поэтому, если вам действительно нужна эта функция, вы можете просто использовать векторы.

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

В качестве одного из примеров рассмотрим строку, реализованную как массив char *. Обычно для выделения подстрок используются указатели в середине массива. В качестве примера см. Функцию strtok в стандартной библиотеке C. Если бы какой-то заголовок нужно было встраивать непосредственно перед каждым массивом, вам нужно было бы удалить части массива перед подстрокой.

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

Шаблон std :: vector - мой любимый способ сохранить размер массива, привязанного к самому массиву.

C - переносимый язык ассемблера с улучшенным синтаксисом.

В общем нет. Массивы в C и C++ - это просто блоки памяти без прикрепленной бухгалтерской информации. В общем случае это невозможно без сохранения длины массива в памяти и дополнительных накладных расходов.

Исключение составляют статические массивы. Например, если вы объявите: int a[50], то sizeof(a) будет работать. Это возможно, потому что [50] является частью статического типа массива: он известен компилятору. sizeof интерпретируется во время компиляции.

Однако, если вы создадите указатель: int *p = a, тогда sizeof(p) вернет размер указателя, как вы упомянули, а не размер массива, потому что компилятор не знает, на что указывает p.

C++ решил добавить new, чтобы сделать типизированный malloc, тогда new должен знать оба размера e номеров элементов для вызова ctors, поэтому delete для вызова dtors. В первые дни вы должны фактически передать, чтобы удалить числа, которые вы передали объектам new.

string* p = new string[5];
delete[5] p;

Однако они думали, что если использовать new <type> [], накладные расходы на число будут небольшими. Поэтому они решили, что new [n] должен запомнить n и передать его на удаление. Есть три основных способа его реализовать.

1. вести хеш-таблицу указателя на размер
2. написал это прямо рядом с вектором
3. сделай что-нибудь совершенно другое

Возможно, удастся получить такой размер:

size_t* p = new size_t[10];
cout << p[-1] << endl;
// Or
cout << p[11] << endl;

Или, черт возьми, ничего из этого.

На самом деле есть способ определить размер, но он небезопасен и будет отличаться от компилятора к компилятору .... поэтому его вообще не следует использовать.

Когда вы это сделаете: int * arr = новый int [256];

256 не имеет значения, вам будет предоставлено 256 * sizeof (int), предполагая, что для этого случая 1024, это значение будет сохранено, вероятно, в (arr - 4)

Итак, чтобы дать вам количество "предметов"

int * p_iToSize = arr - 4;

printf ("Количество элементов% d", * p_iToSize / sizeof (int));

Для каждого malloc, new, независимо от того, что предшествует полученному вами блоку памяти Continos, также выделяется пространство, зарезервированное с некоторой информацией о блоке памяти, который вам был предоставлен.

Is there any way to determine the size of a C++ array programmatically? And if not, why?

1. Нет, если вы сами не отслеживаете это.
2. Потому что, если компилятору не нужно сообщать об этой информации никому, кроме себя, он меньше ограничивает компилятор. Желательно это или нет - вопрос спорный.

@ Дима,

How would the compiler know what the size of p is?

Компилятор должен знать размер p; в противном случае он не сможет реализовать delete[]. Компилятору не нужно никому сообщать, как он это выясняет.

Чтобы убедиться в этом, сравните указатель, возвращаемый operator new[], с указателем, возвращаемым new[].

Компилятор не может этого знать

char *ar = new char[100] 

представляет собой массив из 100 символов, потому что он не создает фактический массив в памяти, он просто создает указатель на 100 неинициализированных байтов в памяти.

Если вы хотите узнать размер данного массива, просто используйте std :: vector. std :: vector - это просто лучший массив.

Когда вы создаете указатели на массивы (создаете оболочку с шаблоном для указателей), вы не можете, но когда вы создаете массив объектов, Вы можете получить размер массива так:

char* chars=new char[100];
printf("%d",*((int*)chars-1));

Функция delete[] должна деконструировать все объекты в ней. для этого ключевое слово new[] помещает количество элементов за всем массивом.

Тело массива выглядит так:

int count;
ObjectType* data; //This value is returned when using new[]

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

В случае объявления и инициализации массива в момент создания вы можете затем просканировать его, а затем сгенерировать число, которое не соответствует ни одному из элементов массива. Но если вы затем измените один из элементов, вы не узнаете, хранит ли этот элемент то же значение, что и последний элемент, поэтому вам придется сгенерировать новое число для сохранения в последнем элементе. Пройдя через все это, вы с таким же успехом можно просто сохранить в переменной общее количество элементов на момент создания. И это, вероятно, будет иметь место, если вы используете массив только внутри функции.

В зависимости от вашего приложения вы можете создать «контрольное значение» в конце вашего массива.

У контрольного значения должно быть какое-то уникальное свойство.

Затем вы можете обработать массив (или выполнить линейный поиск) для контрольного значения, считая по мере продвижения. Как только вы достигнете значения дозорного, у вас будет счетчик массива.

Для простой строки C завершающий символ \ 0 является примером контрольного значения.

Немного волшебства:

template <typename T, size_t S>
inline
size_t array_size(const T (&v)[S]) 
{ 
    return S; 
}

И вот как мы это делаем в C++ 11:

template<typename T, size_t S>
constexpr 
auto array_size(const T (&)[S]) -> size_t
{ 
    return S; 
}

Теперь есть std :: array, эффективная оболочка времени компиляции вокруг массива постоянного размера:

#include <array>

int main (int argc, char** argv)
{
    std::array<int, 256> arr;
    printf("Size of arr: %ld\n", arr.size());
}

Параметры <type, #elements>.

Вы также получаете несколько других тонкостей, таких как итераторы, empty () и max_size ().

я делаю это путем деления размера массива на размер первого элемента

int intarray[100];
printf ("Size of the array %d\n", (sizeof(intarray) / sizeof(intarray[0]));

Он печатает 100