Выбор типа индексных переменных

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

std::vector<int> vec;
....

for(int i = 0; i < vec.size(); ++i)
....

Это заставит компилятор выдавать предупреждение о смешанном использовании переменных со знаком и без знака. если я сделаю индексную переменную как for( size_t i = 0; i < vec.size(); i++ ), (или unsigned int), это решит проблемы.

Когда речь идет о более конкретном использовании типов окон, большинство API-интерфейсов Windows имеют дело с DWORD (который определен как unsigned long).

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

DWORD dwCount;
....

for(DWORD i = 0; i < dwCount; ++i)
....

Я нахожу это немного странным. Это может быть проблема с восприятием.

Я согласен, что мы должны использовать индексную переменную одного типа, чтобы избежать проблем с диапазоном, которые могут возникнуть с индексными переменными. Например, если мы используем

_int64 i64Count; // 
....

for(_int64 i = 0; i < i64Count; ++i)
....

Но в случае DWORD, или целых чисел без знака, есть ли проблемы при переписывании его как

for(int i = 0; (size_t)i < vec.size(); ++i)

Как большинство людей работают с похожими проблемами?

Vector имеет typedef, который говорит вам правильный тип для использования: -

for(std::vector<int>::size_type i = 0; i < thing.size(); ++i)
{
}

Это почти всегда определяется как size_t, но вы не можете полагаться на это

std::vector<int> vec;

for(int i = 0; i < vec.size(); ++i)

Для этого используйте итератор, а не forцикл.

Для других, пока тип переменной имеет одинаковый размер, static_castдолжен работать нормально (то есть, DWORDчтобы int16_t)

Случай, который вы описали, тоже не нравится в C ++. Но я научился жить с этим, либо используя

for( size_t i = 0; i < vec.size(); i++ )

или же

for( int i = 0; i < (int)vec.size(); i++ )

(конечно, последнее только тогда, когда нет риска получить некоторое переполнение int).

Причина, по которой он предупреждает вас о сравнении подписанного и неподписанного, заключается в том, что подписанное значение, скорее всего, будет преобразовано в неподписанное, что может не соответствовать вашим ожиданиям

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

Вместо этого используйте неподписанный тип (например unsigned int, size_tили, как рекомендует John B , std::vector<int>::size_type) для индексной переменной:

for(unsigned int i = 0; i < vec.size(); i++)

Будьте осторожны при обратном отсчете:

for(unsigned int i = vec.size()-1; i >= 0; i--) // don't do this!

Выше не будет работать, потому что i >= 0всегда верно, когда iне подписано. Вместо этого используйте « оператор стрелки » для циклов, которые ведут обратный отсчет:

for (unsigned int i = vec.size(); i-- > 0; )
    vec[i] = ...;

Как указывают другие ответы, вы обычно хотите использовать итератор для обхода vector. Вот синтаксис C ++ 11:

for (auto i = vec.begin(); i != vec.end(); ++i)

Новая опция для C ++ 11, вы можете делать такие вещи, как следующие

for(decltype(vec.size()) i = 0; i < vec.size(); ++i) {...}

и

for(decltype(dWord) i = 0; i < dWord; ++i) {...}

Хотя он повторяет чуть больше, чем это делает базовый цикл for, он не столь многословен, как до -11 способов определения значений, и последовательное использование этого шаблона будет работать для большинства, если не для всех возможных терминов, которые вы могли бы хочу сравнить с, что делает его отличным для рефакторинга кода. Это даже работает для простых случаев, подобных этому:

int x = 3; int final = 32; for(decltype(final) i = x; i < final; ++i)

Кроме того, хотя вы должны использовать autoвсякий раз, когда вы устанавливаете iкакое-либо интеллектуальное значение (например vec.begin()), оно decltypeработает, когда вы устанавливаете постоянную, например, ноль, где auto просто разрешит это значение, intпотому что 0 - это простой целочисленный литерал.

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

Я использую приведение к int, как в for (int i = 0; i < (int)v.size(); ++i). Да, это некрасиво. Я виню в этом глупый дизайн стандартной библиотеки, где они решили использовать целые числа без знака для представления размеров. (Чтобы ... что? Расширить диапазон на один бит?)