Sehr brutaler Austausch mit Vorlage, XOR und Zeiger auf den Speicher

Question

Was sind die meisten Bedrohungen für die Verwendung einer solchen Implementierung von Swap? Neben Fadensicherheit und schlechter Optimierung. Wann schlägt es fehl (Gegenbeispiel)?

template<typename T> 
void swapViaMemory(T& left, T& right) { 
    if(&left == &right) { return ; } 

    unsigned int tSize = sizeof(T); 
    unsigned char* lPtr = reinterpret_cast<unsigned char*>(&left); 
    unsigned char* rPtr = reinterpret_cast<unsigned char*>(&right); 

    for(unsigned int i = 0; i < tSize; ++i) { 
     *(lPtr + i) ^= *(rPtr + i); 
     *(rPtr + i) ^= *(lPtr + i); 
     *(lPtr + i) ^= *(rPtr + i); 
    } 
} 

Sorry für Grammatikfehler und falsche Schreibweisen (=

Answer 1

Wenn T ein Element enthält, das zu einem anderen ihrer Mitte ein Zeiger oder eine Referenz ist dies fehlschlagen wird (die Absicht Annahme, daß für das Zeiger/Referenzelement immer Punkt/siehe das Datenelement, das zu dieser Instanz gehört).

struct foo 
{ 
    foo() : i(), ref_i(i), ptr_i(&i) {} 
    int i; 
    int& ref_i; 
    int *ptr_i; 
}; 

Wenn zwei Objekte foo, sagen f1 & f2 sind swapViaMemory vertauscht Verwendung nach Swapping, f1.ref_i und f1.ptr_i beziehen/Punkt f2.i und umgekehrt. Im Fall des Referenzelements ruft dies ein undefiniertes Verhalten auf, da es illegal ist, eine Referenz neu zu setzen.

Answer 2

Es scheitert in der Förder Vorsatz.

Welche der primäre Zweck des Codes ist.

template<typename T> 
    typename std::enable_if<std::is_pod<T>, void>::type 
    swapViaMemory(T& left, T& right) 
{ 
    using std::swap; 

    swap(left, right); 
} 

Answer 3

Neben schrecklich sein verschleiert, wenn die Besetzung links und rechts auf die gleiche Adresse zeigt

Da a^a = 0 (das ist, was Sie für diesen ‚Trick‘ verwenden)

Wenn left == right (und lässt annehmen, dass es ein 1-Byte-Einheit ist enthalten 'a' Dann tun Sie:

a^a = 0 
0^a = a 
a^a = 0 

Answer 4

Es ruft nicht definiertes Verhalten, wenn T ist kein trivial kopierbarer Typ.

Answer 5

Say für:

struct B{ 
    virtual ~B() {} 
}; 
struct X : B 
{ 
    int x; 
    ~X() { std::cout << x; } 
}; 
struct Y : B 
{ 

}; 

//... 
X x = X(); 
Y y; 
swapViaMemory<B>(x,y);