Scambio molto brutale usando template, xor e puntatori alla memoria

Question

Quali sono le maggiori minacce nell'utilizzo di tale implementazione di swap? Oltre alla sicurezza del thread e alla scarsa ottimizzazione. Quando fallisce (controesempio)?

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); 
    } 
} 

dispiace per gli errori di grammatica e di ortografia (=

Answer 1

Se T contiene un membro che è un puntatore o riferimento ad un altro dei suoi membri fallirà (supponendo l'intento è per il membro puntatore/riferimento sempre punto/consultare il membro dati appartenente a quell'istanza).

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

Se due foo oggetti, dicono f1 & f2 vengono scambiati utilizzando swapViaMemory, dopo lo scambio, f1.ref_i e f1.ptr_i farà riferimento/scegliere f2.i e viceversa. Inoltre, nel caso del membro di riferimento, questo richiama un comportamento indefinito poiché è illegale riposizionare un riferimento.

Answer 2

Fallisce nel trasporto di intenti.

Qual è lo scopo primario del codice.

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

Oltre ad essere terribilmente offuscato fallisce se il cast di sinistra e destra puntano allo stesso indirizzo

Dal a^a = 0 (che è quello che si usa per questo 'trucco')

Se left == right (e consente di assumere è un'entità 1 byte contenente 'a' allora si farà:

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

Answer 4

Si invoca un comportamento indefinito se T non è un tipo banalmente copiabile.

Answer 5

Say Per:

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);