cosa significa l'errore quando sto compilando C++ con il compilatore g ++?

Question

utilizzando il seguente codice:

#include<iostream> 
#include<vector> 

using namespace std; 

int main() 
{ 
    vector<int> ivec; 
    for(vector<int>::size_type ix = 0; ix != 10; ix++) 
    { 
     ivec.push_back(ix); 
    } 
    vector<int>::iterator mid = (ivec.begin() + ivec.end())/2; 
    cout << *mid << endl; 
    return 0; 
} 

ottengo un errore compilazione con g ++:

iterator_io.cpp: In function `int main()': 
iterator_io.cpp:13: error: no match for 'operator+' in '(&ivec)->std::vector<_Tp,    _Alloc>::begin [with _Tp = int, _Alloc = std::allocator<int>]() + (&ivec)->std::vector<_Tp, _Alloc>::end [with _Tp = int, _Alloc = std::allocator<int>]()' 
/usr/lib/gcc/x86_64-redhat-linux/3.4.5/../../../../include/c++/3.4.5/bits/stl_iterator.h:654: note: candidates are: __gnu_cxx::__normal_iterator<_Iterator, _Container> __gnu_cxx::__normal_iterator<_Iterator, _Container>::operator+(const typename std::iterator_traits<_Iterator>::difference_type&) const [with _Iterator = int*, _Container = std::vector<int, std::allocator<int> >] 
/usr/lib/gcc/x86_64-redhat-linux/3.4.5/../../../../include/c++/3.4.5/bits/stl_bvector.h:261: note:     std::_Bit_iterator std::operator+(ptrdiff_t, const std::_Bit_iterator&) 
/usr/lib/gcc/x86_64-redhat-linux/3.4.5/../../../../include/c++/3.4.5/bits/stl_bvector.h:345: note:     std::_Bit_const_iterator std::operator+(ptrdiff_t, const std::_Bit_const_iterator&) 
/usr/lib/gcc/x86_64-redhat-linux/3.4.5/../../../../include/c++/3.4.5/bits/stl_iterator.h:765: note:     __gnu_cxx::__normal_iterator<_Iterator, _Container> __gnu_cxx::operator+(typename __gnu_cxx::__normal_iterator<_Iterator, _Container>::difference_type, const __gnu_cxx::__normal_iterator<_Iterator, _Container>&) [with _Iterator = int*, _Container = std::vector<int, std::allocator<int> >] 

So che l'ivec.end() non può essere utilizzato come un normale elemento del vettore. Ma non riesco a capire cosa significhi l'informazione di errore ... qualcosa su operator +?

Answer 1

Si non è possibile aggiungere due iteratori insieme.

operator+ non è definito per due iteratori, poiché tale operazione non avrebbe senso. Gli iteratori sono una sorta di generalizzazione sui puntatori: indicano l'elemento specifico memorizzato nel contenitore. A quale elemento sta puntando la somma degli iteratori?

Tuttavia, quando si utilizza un vettore, è possibile aggiungere interi a iteratori, come quella:

vec.begin() + vec.size()/2 

, per questo avete candidates are: (...) nel messaggio di errore, seguito da alcune definizioni di operator+.

Nel tuo caso il modo migliore, più pulito e non sarà utilizzando le iteratori, ma semplice ottenere il valore dalla posizione specificata:

int mid = vec[vec.size()/2]; 

Answer 2

Non è possibile aggiungere due iteratori insieme, perché gli iteratori non sono interi. Questo è ciò che significa il messaggio di errore. Se si desidera accedere all'elemento nel mezzo di un vettore, utilizzare ivec[ivec.size()/2].

Answer 3

Significa semplicemente che gli iteratori vector non hanno operatore di addizione (+). Non è possibile aggiungere ivec.begin() e ivec.end().

Per ottenere l'elemento centrale, si può semplicemente utilizzare l'operatore pedice:

cout << ivec[ivec.size()/2] << endl; 

Se ti ostini a usare un iteratore, si può ottenere un iteratore che punta al centro in questo modo:

vector<int>::iterator mid = ivec.begin(); 
mid += ivec.size()/2; 
cout << *mid << endl; 

È possibile eseguire questa operazione perché l'iteratore vector è un iteratore di accesso casuale (in tutte le implementazioni di cui sono a conoscenza incapsula un puntatore effettivo sui dati del contenitore non elaborati).

Answer 4

Non è possibile aggiungere iteratori. Cosa si può fare:

vector<int>::iterator mid = ivec.begin() + distance(ivec.begin(), ivec.end())/2; 

Answer 5

non è possibile aggiungere due iteratori

uso presso per ottenere l'elemento centrale:

ivec.at (ivec.size()/2);

Answer 6

Non è possibile aggiungere iteratori.

Che cosa si vorrà utilizzare è una combinazione di std::distance() e std::advance():

vector<int>::iterator mid = std::advance(ivec.begin(), std::distance(ivec.begin(), ivec.end())/2); 

Perché utilizzare std::advance() invece di operatore di addizione del iteratore? std::advance() funziona in modo ottimale indipendentemente dal tipo di iteratore (accesso casuale, solo inoltro, bidirezionale, ecc.), Pertanto se si passa da std::vector a std::list, il codice sopra riportato può rimanere invariato e continuare a funzionare in modo ottimale.