Hoán đổi rất tàn bạo bằng cách sử dụng mẫu, xor và con trỏ tới bộ nhớ

Question

Các mối đe dọa nhất của việc sử dụng việc thực hiện hoán đổi này là gì? Bên cạnh luồng an toàn và tối ưu hóa kém. Khi nào nó thất bại (counterexample)?

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

Xin lỗi cho những sai lầm ngữ pháp và lỗi chính tả (=

Answer 1

Nếu T chứa một thành viên mà là một con trỏ hoặc tham chiếu đến một của các thành viên này sẽ thất bại (giả sử mục đích là cho các thành viên con trỏ/tham chiếu đến luôn điểm/tham khảo thành viên dữ liệu thuộc về cá thể đó).

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

Nếu hai foo đối tượng, nói f1 & f2 được hoán đổi sử dụng swapViaMemory, sau khi trao đổi, f1.ref_i và f1.ptr_i sẽ giới thiệu/điểm đến f2.i và ngược lại. Ngoài ra, trong trường hợp thành viên tham chiếu, điều này gọi hành vi không xác định vì nó là bất hợp pháp để đặt lại một tham chiếu.

Answer 2

Nó thất bại trong vận chuyển về ý định.

Đó là mục đích chính của mã.

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

Bên cạnh đó là khủng khiếp obfuscated nó thất bại nếu các diễn viên của trái và phải điểm đến cùng một địa chỉ

Kể từ a^a = 0 (đó là những gì bạn sử dụng cho điều này 'lừa')

Nếu left == right (và cho phép giả định đó là một thực thể 1 byte chứa 'a' Sau đó, bạn sẽ làm gì:

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

Answer 4

Nó gọi hành vi undefined nếu T không phải là một loại có thể sao chép được.

Answer 5

Say cho:

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