सी ++ 11 (या बाद में) में बाइट सरणी से ऑब्जेक्ट को deserializing का कोई अपरिभाषित व्यवहार तरीका क्या है?

Question

संरेखण के मुद्दों को दूर करने के लिए, मुझे अस्थायी में memcpy की आवश्यकता है। उस प्रकार का अस्थायी होना चाहिए? जीसीसी शिकायत है कि निम्नलिखित reinterpret_cast सख्त अलियासिंग नियमों को तोड़ने जाएगा:

template <typename T> 
T deserialize(char *ptr) { 
    static_assert(std::is_trivially_copyable<T>::value, "must be trivially copyable"); 
    alignas(T) char raw[sizeof(T)]; 
    memcpy(raw, ptr, sizeof(T)); 
    return *reinterpret_cast<T *>(raw); 
} 

(जैसे जब टी "लंबे समय" है)।

मैं टी को परिभाषित नहीं करना चाहता, क्योंकि मैं इसे ओवरराइट करने से पहले टी बनाना नहीं चाहता हूं।

एक संघ में, एक सदस्य नहीं लिख रहा है और फिर एक और गिनती को अपरिभाषित व्यवहार के रूप में पढ़ रहा है?

T result; 
char * p = reinterpret_cast<char *>(&result); // or std::addressof(result) ! 

std::memcpy(p, ptr, sizeof(T));     // or std::copy!! 

return result; 

कोई अलियासिंग उल्लंघन:

template<typename T> 
T deserialize(char *ptr) { 
    union { 
     char arr[sizeof(T)]; 
     T obj; 
    } u; 

    memcpy(u.arr, ptr, sizeof(T)); // Write to u.arr 
    return u.obj; // Read from u.obj, even though arr is the active member. 
} 

Answer 1

यह क्या आप चाहते हैं। यदि आप T चाहते हैं, तो आपको T होना चाहिए। यदि आपका प्रकार छोटा रूप से कॉपी करने योग्य है, तो उम्मीद है कि यह भी मामूली रूप से रचनात्मक है और इसकी कोई कीमत नहीं है। किसी भी घटना में, आपको रिटर्न ऑपरेंड को फंक्शन रिटर्न वैल्यू में कॉपी करना होगा, और वह प्रतिलिपि बनाई गई है, इसलिए यहां वास्तव में कोई अतिरिक्त लागत नहीं है।

Answer 2

आप std::aligned_storage क्लास टेम्पलेट का उपयोग करना चाहते हैं। यह इस सटीक समस्या को संभालने के लिए डिज़ाइन किया गया है। यहां आपके प्रश्न में आपके चेक के आधार पर कुछ SFINAE के साथ एक नमूना समाधान है।

template<class T> 
typename std::enable_if<std::is_trivially_copyable<T>::value, T>::type deserialize(const char *data) { 
    typename std::aligned_storage<sizeof(T), alignof(T)>::type destination; 
    std::memcpy(&destination, data, sizeof(T)); 
    return reinterpret_cast<T &>(destination); 
}