Perché std :: swap non funziona su elementi <bool> vettoriali in Clang / Win?

Ho un codice come questo:

#include <vector>
#include <utility>

int main()
{
   std::vector<bool> vb{true, false};
   std::swap(vb[0], vb[1]);
}

Argomenti sulla sanità mentale a vector<bool>parte, questo funzionava perfettamente su:

• Clang per Mac
• Visual Studio per Windows
• GCC per Linux

Quindi ho provato a costruirlo con Clang su Windows e ho ricevuto il seguente errore (abbreviato):

error: no matching function for call to 'swap'
                                std::swap(vb[0], vb[1]);
                                ^~~~~~~~~

note: candidate function [with _Ty = std::_Vb_reference<std::_Wrap_alloc<std::allocator<unsigned int> > >, $1 = void] not viable: expects an l-value for 1st argument
inline void swap(_Ty& _Left, _Ty& _Right) _NOEXCEPT_COND(is_nothrow_move_constructible_v<_Ty>&&

Sono sorpreso che i risultati differiscano tra le implementazioni.

Perché non funziona con Clang su Windows?

Lo standard non richiede che questo si compili su nessuna toolchain!

Per prima cosa ricorda che vector<bool>è strano e la sottoscrizione ti dà un oggetto temporaneo di un tipo proxy chiamato std::vector<bool>::reference, piuttosto che un effettivo bool&.

Il messaggio di errore indica che non è possibile associare questo temporaneo a un constriferimento non di valore nell'implementazione generica template <typename T> std::swap(T& lhs, T& rhs).

Estensioni!

Tuttavia, risulta che libstdc ++ definisce un sovraccarico per std::swap(std::vector<bool>::reference, std::vector<bool>::reference), ma questa è un'estensione dello standard (o, se è presente, non riesco a trovare alcuna prova).

Anche libc ++ fa questo .

Immagino che l'implementazione stdlib di Visual Studio, che stai ancora usando, non lo fa , ma poi per aggiungere un insulto a un infortunio puoi associare i temporali ai riferimenti lvalue in VS (a meno che tu non stia usando la modalità di conformità), quindi il la funzione standard, "generica", std::swapfunziona fino a quando non si sostituisce il compilatore VS al compilatore Clang più rigoroso.

Di conseguenza, hai fatto affidamento sulle estensioni su tutte e tre le toolchain per le quali ha funzionato per te e la combinazione Clang su Windows è l'unica che mostra effettivamente una rigorosa conformità.

(Secondo me, queste tre toolchain avrebbero dovuto diagnosticare questo, quindi non hai spedito codice non portatile per tutto il tempo. 😊)

E adesso?

Potrebbe essere allettante aggiungere la tua specializzazione di std::swape std::vector<bool>::reference, ma non ti è permesso farlo per i tipi standard; in effetti, sarebbe in conflitto con i sovraccarichi che libstdc ++ e libc ++ hanno scelto di aggiungere come estensioni.

Quindi, per essere portatile e conforme, è necessario modificare il codice .

Forse un buon vecchio stile:

const bool temp = vb[0];
vb[0] = vb[1];
vb[1] = temp;

Oppure utilizza la speciale funzione di membro statico che fa esattamente quello che volevi :

std::vector<bool>::swap(vb[0], vb[1]);

Anche ortografico come segue:

vb.swap(vb[0], vb[1]);