size_t по сравнению с интервалом в C++ и/или C

Может быть несколько причин:

• Тип (size_t) может быть определен как наибольшее целое число без знака на этой платформе. Например, оно может быть определено как 32-битное целое или 64-битное целое число или что-то еще, способное хранить беззнаковые значения большой длины
• . Чтобы при чтении программы было ясно, что значение имеет размер, а не просто «обычный» int

Если вы пишете приложение, предназначенное только для себя и / или выбрасываемое, вы, вероятно, сможете использовать базовый int. Если вы пишете библиотеку или что-то существенное, лучше всего подойдет size_t.

Все контейнеры в stl имеют различные определения типов. Например, value_type - это тип элемента, а size_type - это номер сохраненного типа. Таким образом, контейнеры являются полностью универсальными в зависимости от платформы и реализации.

Если вы создаете свои собственные контейнеры, вы также должны использовать size_type . Обычно это делается

typedef std::size_t size_type;

Если вам нужен размер контейнера, вы должны написать

typedef vector<int> ints;
ints v;
v.push_back(4);
ints::size_type s = v.size();

Что приятно, если позже вы захотите использовать список, просто измените typedef на

typedef list<int> ints;

И он все равно будет работать!

Я предполагаю, что вы имеете в виду "size_t" - это способ указать целое число без знака (целое число, которое может быть только положительным, но не отрицательным) - это имеет смысл для размеров контейнеров, поскольку у вас не может быть массива размером -7. Я бы не сказал, что вам нужно использовать size_t, но он указывает другим, использующим ваш код, «Это число всегда положительное». Это также дает вам больший диапазон положительных чисел, но это, скорее всего, будет неважно, если у вас нет очень больших контейнеров.

C ++ - это язык, который может быть реализован на различных аппаратных архитектурах и платформах. Со временем он поддерживал 16-, 32- и 64-разрядную архитектуру и, вероятно, другие в будущем. size_type и другие псевдонимы типов позволяют библиотекам изолировать программистов / код от деталей реализации.

Предполагая, что size_type использует 32 бита на 32-битных машинах и 64 бита на 64 -битные машины, тот же исходный код, вероятно, будет работать лучше, если вы использовали size_type там, где это необходимо. В большинстве случаев можно предположить, что это будет то же самое, что и unsigned int , но это не гарантируется.

size_type используется для выражения емкости контейнеров STL, таких как std :: vector , тогда как size_t используется для выражения байтового размера объекта в C / C ++.

int не гарантируется, что в спецификации будет 4 байта, поэтому они не надежный. Да, size_type предпочтительнее int

void f1(size_t n) {
    if (n <= myVector.size()) { assert(false); }
    size_t n1 = n - myVector.size(); // bug! myVector.size() can be > n       
    do_stuff_n_times(n1);
}

void f2(int n) {
    int n1 = n - static_cast<int>(myVector.size());
    assert(n1 >= 0);
    do_stuff_n_times(n1);
}

f1 () и f2 () имеют одну и ту же ошибку, но обнаружить проблему в f2 () проще. Для более сложного кода ошибки арифметики целых чисел без знака не так легко выявить.

Лично я использую подписанное int для всех моих размеров, если не нужно использовать unsigned int. Я никогда не сталкивался с ситуацией, когда мой размер не помещается в 32-битное целое число со знаком. Я, вероятно, буду использовать 64-битные целые числа со знаком, прежде чем использовать беззнаковые 32-битные целые числа.

Проблема с использованием целых чисел со знаком для размера - это много static_cast от size_t до int в вашем коде.

size_t беззнаковый, поэтому даже если они оба 32-битные, это не означает то же самое, что и неквалифицированное int. Я не уверен, почему они добавили этот тип, но сегодня на многих платформах sizeof (size_t) == sizeof (int) == sizeof (long) , так что какой тип вы выберете, зависит от вас. Обратите внимание, что эти отношения не гарантируются стандартом и быстро устаревают по мере появления 64-битных платформ.

Для вашего собственного кода, если вам нужно представить что-то, что концептуально является «размером» и никогда не может быть отрицательный, size_t будет хорошим выбором.

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