In C++, perché non possiamo confrontare gli iteratori usando> e <?

Question

Mi è stata fatta questa domanda che non so davvero perché.

Se si dispone di un puntatore int * x;
È possibile confrontare i puntatori con > e < perché sta per la cosa posizione memoria come 0x0000 0x0004 0x0008, ecc So iteratori e puntatori sono diversi, ma si comportano in modo molto simile.

Ad esempio:

vector<int> myVector; 

for(int i = 1; i < 101; i++) 
{ 
    myVector.push_back(i); 
} 

vector<int>::iterator it = myVector.begin(); 
while(it != myVector.end()) //Why can't we write it < myVector.end() 
{ 
    cout << *it << endl; 
    it++; 
} 

Perché non possiamo scriverlo < myVector.end() nella dichiarazione while? So che ha a che fare senza sovraccaricare in STL. Tuttavia, scrivere &*it < &*myVector.end() funziona perché ottiene la posizione di memoria che rivela dire 0x0004 0x0008, ecc.

Perché è questo?

Answer 1

operator< e operator> possono essere utilizzati solo con RandomAccessIterator. Ma operator!= può anche essere utilizzato con InputIterator, ForwardIterator e BidirectionalIterator. Per il codice di esempio, it != myVector.end() e it < myVector.end() hanno lo stesso effetto, ma il primo è più generale, quindi il codice funziona anche con altri iteratori (ad esempio iteratori di std::list o std::map ecc.).

BTW: Il codice di esempio sarà bene usare operator< o operator>, dal momento che l'iteratore di std::vector è RandomAccessIterator.

Answer 2

std::vector::iterator è un iteratore di accesso casuale e puoi certamente confrontarli con < e >.

Tuttavia, solo gli iteratori di accesso casuale possono essere confrontati utilizzando qualsiasi valore diverso da == e !=. Gli iteratori bidirezionali, avanti e input definiscono solo gli operatori di confronto di uguaglianza/diseguaglianza.

A , ad esempio è un iteratore che punta a un membro non specificato di std::list. In questo caso, non c'è alcun significato per nessun altro tipo di confronto.

Answer 3

Il problema è che < e >non può essere sempre utilizzato con iteratori, in quanto solo alcuni tipi di iteratori supportano tali operazioni (ovvero iteratori ad accesso casuale e simili). D'altra parte, operazioni di confronto come != sono sempre disponibili.

Ora, perché preoccuparsi di utilizzare < e > se != ha lo stesso effetto e funziona sempre?

---

Supponiamo di avere un po 'di codice generico:

template <class It> 
void foo(It begin, It end) 
{ 
    while (--end != begin) 
     apply(*begin); 

} 

Il codice verrà compilato per i puntatori, per esempio, ma non per myList.begin().