मेमोरी

Question

पर टेम्पलेट, एक्सओआर और पॉइंटर्स का उपयोग करके बहुत क्रूर स्वैप स्वैप के ऐसे कार्यान्वयन का उपयोग करने के सबसे खतरे क्या हैं? थ्रेड सुरक्षा और खराब अनुकूलन के अलावा। यह कब विफल रहता है (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); 
    } 
} 

व्याकरण की गलतियों के लिए क्षमा करें, और वर्तनी (=

Answer 1

तो T एक सदस्य जो एक सूचक या उसके सदस्यों का एक और इस असफल हो जायेगी के संदर्भ में होता है (आशय यह सोचते हैं सूचक/संदर्भ सदस्य को हमेशा बिंदु/का उल्लेख के लिए है उस उदाहरण से संबंधित डेटा सदस्य)।

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

तो दो foo वस्तुओं, कहते हैं कि f1 & f2swapViaMemory का उपयोग कर लगा दिया जाता था गमागमन, f1.ref_i और f1.ptr_if2.i और इसके विपरीत का उल्लेख/बिंदु के बाद,। इसके अलावा, संदर्भ सदस्य के मामले में, यह अनिर्धारित व्यवहार का आह्वान करता है क्योंकि संदर्भ को फिर से सीट करना अवैध है।

Answer 2

यह आशय का सन्देश देने में विफल रहता है।

कौन सा कोड का प्राथमिक उद्देश्य है।

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

बुरी होने के अलावा obfuscated यह विफल रहता है अगर बाएं और दाएं बिंदु एक ही पते पर इंगित करता है।

a^a = 0 के बाद से (जो आप इस 'चाल' के लिए करते हैं)

तो left == right (और मान लेते हैं कि यह एक 1 बाइट युक्त 'a' तो फिर तुम क्या करोगे इकाई है देता है:

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

Answer 4

यह अपरिभाषित व्यवहार करता है, तो आह्वान टी एक मामूली प्रतिलिपि प्रकार नहीं है।

Answer 5

कहो के लिए:

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