Perché il vettore :: reference non restituisce il riferimento a bool?

#include  struct A { void foo(){} }; template void callIfToggled( bool v1, bool &v2, T & t ) { if ( v1 != v2 ) { v2 = v1; t.foo(); } } int main() { std::vector v= { false, true, false }; const bool f = false; A a; callIfToggled( f, v[0], a ); callIfToggled( f, v[1], a ); callIfToggled( f, v[2], a ); } 

La compilazione dell’esempio sopra produce un errore successivo:

 dk2.cpp: In function 'int main()': dk2.cpp:29:28: error: no matching function for call to 'callIfToggled(const bool&, std::vector::reference, A&)' dk2.cpp:29:28: note: candidate is: dk2.cpp:13:6: note: template void callIfToggled(bool, bool&, T&) 

Ho compilato usando g ++ (versione 4.6.1) in questo modo:

 g++ -O3 -std=c++0x -Wall -Wextra -pedantic dk2.cpp 

La domanda è: perché questo accade? Il vector::reference not bool& ? O è un bug del compilatore?
Oppure sto cercando qualcosa di stupido? 🙂

Il vettore è specializzato per il bool .

È considerato un errore dello standard. Usa invece il vector :

 template struct foo { using type = t; }; template<> struct foo { using type = char; }; template using fixed_vector = std::vector::type, p...>; 

Occasionalmente potresti aver bisogno di riferimenti a un bool contenuto nel vettore. Sfortunatamente, usando il vector puoi solo dare dei riferimenti ai caratteri. Se hai davvero bisogno di bool& , controlla la libreria Boost Containers . Ha una versione non specificata del vector .

Le tue aspettative sono normali, ma il problema è che std::vector è stata una sorta di esperimento del comitato C ++. In realtà è una specializzazione di template che memorizza i valori bool in memoria: un bit per valore.

E dal momento che non puoi avere un riferimento a un po ‘, c’è il tuo problema.

std::vector è un contenitore non conforms. Per ottimizzare lo spazio, imballa bool e non può fornire riferimenti.

Usa invece boost::dynamic_bitset .

std::vector< bool > impacchetta il suo contenuto in modo tale che ogni valore booleano sia memorizzato in un bit, otto bit in un byte. Questo è efficiente in termini di memoria ma intensivo dal punto di vista computazionale, poiché il processore deve eseguire l’aritmetica per accedere al bit richiesto. E non funziona con il riferimento bool o la semantica del puntatore, poiché i bit all’interno di un byte non hanno indirizzi nel modello di oggetti C ++.

Puoi ancora dichiarare una variabile di tipo std::vector::reference e usarla come se fosse bool& . Ciò consente agli algoritmi generici di essere compatibili.

 std::vector< bool > bitvec( 22 ); std::vector< bool >::reference third = bitvec[ 2 ]; third = true; // assign value to referenced bit 

In C ++ 11, è ansible aggirare questo problema usando auto e lo specificatore && che seleziona automaticamente un riferimento lvalue associato all’elemento vettoriale o un riferimento rvalue associato a un valore temporaneo.

 std::vector< bool > bitvec( 22 ); auto &&third = bitvec[ 2 ]; // obtain a std::vector< bool >::reference third = true; // assign value to referenced bit 

Solo i miei 2 centesimi:

std::vector::reference è un typedef per struct _Bit_reference che è definito come

 typedef unsigned long _Bit_type; struct _Bit_reference { _Bit_type * _M_p; _Bit_type _M_mask; // constructors, operators, etc... operator bool() const { return !!(*_M_p & _M_mask); } }; 

Cambiando la funzione in questo modo, funziona (beh, compila almeno, non ho testato):

 template< typename T > void callIfToggled( bool v1, std::vector::reference v2, T & t ) { bool b = v2; if ( v1 != b ) { v2 = v1; t.foo(); } } 

EDIT: ho cambiato la condizione da (v1! = V2), che non era una buona idea, a (v1! = B).

Costruisci una struttura con un bool e realizza il vector<> usando quel tipo di struct.

Provare:

vector dove sb è struct {boolean b];

allora puoi dire

push_back({true})

fare

typedef struct sbool {bool b;} boolstruct; e quindi vector bs;