Когда использовать std :: size_t?

Мне просто интересно, я должен использовать std::size_tдля петель и прочее вместо int? Например:

#include <cstdint>

int main()
{
    for (std::size_t i = 0; i < 10; ++i) {
        // std::size_t OK here? Or should I use, say, unsigned int instead?
    }
}

В целом, какова лучшая практика относительно того, когда использовать std::size_t?

Хорошее эмпирическое правило для всего, что вам нужно сравнить в условии цикла с чем-то, что, естественно, std::size_tсамо по себе.

std::size_tявляется типом любого sizeofвыражения и, как гарантированно, сможет выражать максимальный размер любого объекта (включая любой массив) в C ++. Кроме того, он гарантированно будет достаточно большим для любого индекса массива, поэтому это естественный тип для цикла по индексу над массивом.

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

size_tтип результата sizeofоператора.

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

Кроме того, использование size_tдля представления размера в байтах помогает сделать код переносимым.

size_tТип предназначен для определения размера чего - то , так что это естественно использовать его, например, получить длину строки , а затем обработки каждого символа:

for (size_t i = 0, max = strlen (str); i < max; i++)
    doSomethingWith (str[i]);

Вы же должны следить за граничные условия, конечно же , так что это тип без знака. Граница в верхней части, обычно не так важна , так как максимум, как правило , большой (хотя это возможно , чтобы получить там). Большинство людей просто используют intдля такого рода вещей, потому что они редко имеют структуры или массивы, которые становятся достаточно большими, чтобы превышать возможности этого int.

Но остерегайтесь таких вещей, как:

for (size_t i = strlen (str) - 1; i >= 0; i--)

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

for (size_t i = strlen (str); i-- > 0; )

Перемещая декремент в побочный эффект условия проверки продолжения после проверки, он выполняет проверку продолжения для значения перед декрементом, но все еще использует уменьшенное значение внутри цикла (именно поэтому цикл выполняется len .. 1вместо, а не из len-1 .. 0).

По определению size_tявляется результатом sizeofоператора. size_tбыл создан для ссылки на размеры.

Количество раз, когда вы что-то делаете (10, в вашем примере) не зависит от размеров, так зачем использовать size_t? intили unsigned intдолжно быть в порядке.

Конечно, это также относится к тому, что вы делаете iвнутри цикла. Если вы передадите его функции, которая принимает unsigned int, например, команду pick unsigned int.

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

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

короткий ответ:

почти никогда

длинный ответ:

Всякий раз, когда вам нужно иметь вектор char больше, чем 2gb в 32-битной системе. В любом другом случае использование подписанного типа намного безопаснее, чем использование неподписанного типа.

пример:

std::vector<A> data;
[...]
// calculate the index that should be used;
size_t i = calc_index(param1, param2);
// doing calculations close to the underflow of an integer is already dangerous

// do some bounds checking
if( i - 1 < 0 ) {
    // always false, because 0-1 on unsigned creates an underflow
    return LEFT_BORDER;
} else if( i >= data.size() - 1 ) {
    // if i already had an underflow, this becomes true
    return RIGHT_BORDER;
}

// now you have a bug that is very hard to track, because you never 
// get an exception or anything anymore, to detect that you actually 
// return the false border case.

return calc_something(data[i-1], data[i], data[i+1]);

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

Это означает, что вы всегда должны конвертировать в size_t и из него всякий раз, когда вы взаимодействуете с std :: Containers, что не очень красиво. Но на нативной конференции авторы c ++ отметили, что проектирование std :: vector с беззнаковым size_t было ошибкой.

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

calc_something(data[size_t(i-1)], data[size_t(i)], data[size_t(i+1)]);

если вы хотите перебрать коллекцию без проверки границ, используйте диапазон на основе:

for(const auto& d : data) {
    [...]
}

Вот несколько слов Бьярна Страуструпа (автора C ++) о том, как стать родным

Для некоторых людей эта ошибка дизайна со знаком / без знака в STL является достаточной причиной, чтобы не использовать std :: vector, а вместо этого собственную реализацию.

Используйте std :: size_t для индексации / подсчета массивов в стиле C.

Для контейнеров STL у вас будет (например) vector<int>::size_type, который должен использоваться для индексации и подсчета векторных элементов.

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

Вскоре большинство компьютеров получат 64-битные архитектуры с 64-битными ОС: они работают с программами, работающими на контейнерах с миллиардами элементов. Затем вы должны использовать size_tвместо intиндекса цикла, иначе ваш индекс будет обернут в элементе 2 ^ 32: th, как в 32-, так и в 64-битной системах.

Готовьтесь к будущему!

При использовании size_t будьте осторожны со следующим выражением

size_t i = containner.find("mytoken");
size_t x = 99;
if (i-x>-1 && i+x < containner.size()) {
    cout << containner[i-x] << " " << containner[i+x] << endl;
}

Вы получите false в выражении if независимо от значения x. Мне потребовалось несколько дней, чтобы понять это (код настолько прост, что я не проводил модульное тестирование), хотя выяснение источника проблемы заняло всего несколько минут. Не уверен, что лучше сделать бросок или использовать ноль.

if ((int)(i-x) > -1 or (i-x) >= 0)

Оба способа должны работать. Вот мой тестовый прогон

size_t i = 5;
cerr << "i-7=" << i-7 << " (int)(i-7)=" << (int)(i-7) << endl;

Выход: i-7 = 18446744073709551614 (int) (i-7) = - 2

Я хотел бы комментарии других.

size_t возвращается различными библиотеками, чтобы указать, что размер этого контейнера не равен нулю. Вы используете его, когда вернетесь однажды: 0

Однако в приведенном выше примере зацикливание на size_t является потенциальной ошибкой. Учтите следующее:

for (size_t i = thing.size(); i >= 0; --i) {
  // this will never terminate because size_t is a typedef for
  // unsigned int which can not be negative by definition
  // therefore i will always be >= 0
  printf("the never ending story. la la la la");
}

использование целых чисел без знака может создать такие тонкие проблемы. Поэтому imho я предпочитаю использовать size_t только тогда, когда я взаимодействую с контейнерами / типами, которые требуют этого.

size_tэто тип без знака, который может содержать максимальное целочисленное значение для вашей архитектуры, поэтому он защищен от целочисленных переполнений из-за знака (знак int, 0x7FFFFFFFувеличенный на 1, даст вам -1) или короткого размера (unsigned short int 0xFFFF, увеличенный на 1, даст вам 0).

Он в основном используется для индексации массивов / циклов / адресной арифметики и так далее. Такие функции, как memset()и одинаковые, принимают size_tтолько потому, что теоретически у вас может быть блок памяти размером 2^32-1(на 32-битной платформе).

Для таких простых циклов не беспокойтесь и используйте только int.

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

Некоторые функции возвращают size_t, и ваш компилятор предупредит вас, если вы попытаетесь сделать сравнение.

Избегайте этого, используя соответствующий тип данных со знаком / без знака или просто приведение типа для быстрого взлома.

size_t без знака int. поэтому, когда вы хотите unsigned int, вы можете использовать его.

Я использую его, когда хочу указать размер массива, счетчик и т. Д ...

void * operator new (size_t size); is a good use of it.