Scelta del tipo di variabili indice

Usiamo il tipo intero che rappresenta le variabili indice per la maggior parte del tempo. Ma in alcune situazioni, siamo costretti a scegliere

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

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

Ciò farà sì che il compilatore sollevi l'avvertimento che l'uso misto di variabili firmate / non firmate. se faccio l'indice variabile come for( size_t i = 0; i < vec.size(); i++ ), (o un unsigned int) risolverà i problemi.

Quando diventa più specifico usare i tipi di Windows, la maggior parte delle API di Windows hanno a che fare con DWORD (che è stato tipizzato come unsigned long).

Quindi, quando utilizzo un'iterazione simile, causerà nuovamente lo stesso avviso. Ora se lo riscrivo come

DWORD dwCount;
....

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

Lo trovo un po 'strano. Potrebbe essere il problema con le percezioni.

Concordo sul fatto che dovremmo utilizzare lo stesso tipo di variabile indice per evitare che si possano verificare problemi di intervallo con le variabili indice. Per esempio se stiamo usando

_int64 i64Count; // 
....

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

Ma nel caso di DWORD, o numeri interi senza segno, ci sono problemi a riscriverlo come

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

In che modo la maggior parte delle persone lavora con problemi simili?

vector ha un typedef che ti dice il tipo corretto da usare: -

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

È quasi sempre definito come size_t, ma non ci si può fare affidamento

std::vector<int> vec;

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

Usa un iteratore per questo, non un forloop.

Per gli altri, purché il tipo di variabile abbia le stesse dimensioni, static_castdovrebbe funzionare bene (ovvero DWORDa int16_t)

Il caso che hai descritto è anche una delle cose che non mi piacciono in C ++. Ma ho imparato a conviverci, sia usando

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

o

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

(ovviamente, quest'ultimo solo quando non c'è rischio di ottenere un po 'di overflow).

Il motivo per cui ti avvisa del confronto tra firmato e non firmato è perché il valore firmato verrà probabilmente convertito in non firmato, il che potrebbe non essere quello che ti aspetti.

Nel tuo esempio (rispetto inta size_t), intverrà convertito implicitamente in size_t(a meno che in intqualche modo non abbia un intervallo maggiore di size_t). Pertanto, se intè negativo, sarà probabilmente maggiore del valore a cui lo stai confrontando a causa di avvolgimento. Questo non sarà un problema se il tuo indice non è mai negativo, ma riceverai comunque questo avviso.

Invece, utilizzare un tipo unsigned (come ad esempio unsigned int, size_to, come John B raccomanda , std::vector<int>::size_type) per la variabile index:

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

Fai attenzione quando conto alla rovescia, tuttavia:

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

Quanto sopra non funzionerà perché i >= 0è sempre vero quando iè senza segno. Utilizzare invece "l' operatore freccia " per i loop che contano:

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

Come indicano altre risposte, normalmente si desidera utilizzare un iteratore per attraversare a vector. Ecco la sintassi di C ++ 11:

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

Una nuova opzione per C ++ 11, puoi fare cose come le seguenti

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

e

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

Mentre si ripete un po 'più di quanto non farebbe il ciclo for-base di base, non è così prolisso come i modi pre-'11 per specificare i valori, e l'utilizzo di questo modello funzionerà coerentemente per la maggior parte, se non per tutti, i possibili termini che avresti voglio confrontare, il che lo rende ottimo per il refactoring del codice. Funziona anche con casi semplici come questo:

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

Inoltre, mentre dovresti usare autoogni volta che stai impostando iun valore intelligente (come vec.begin()), decltypefunziona quando stai impostando una costante come zero, dove auto lo risolverebbe semplicemente intperché 0 è un semplice numero intero.

Ad essere sincero, mi piacerebbe vedere un meccanismo di compilazione per estendere la autodeterminazione del tipo per gli incrementatori di loop per esaminare il valore confrontato.

Uso un cast per int, come in for (int i = 0; i < (int)v.size(); ++i). Sì, è brutto. Lo biasimo per lo stupido design della libreria standard in cui decisero di usare numeri interi senza segno per rappresentare le dimensioni. (Al fine di ... cosa? Estendere l'intervallo di un bit?)