爲什麼不保證memcpy對非POD類型安全？

Question

我從SO上發佈的幾個問題閱讀了關於這一段的內容。

我不能完全弄清楚爲什麼memcpy不能保證對非POD類型安全。我的理解是，memcpy只是一個按位拷貝。

下面是從標準

POD類型T的報價對於任何對象（比基類子對象等），對象是否保持T類型的有效值， 底層字節（1.7）構成的對象可以被拷貝到char或unsigned char 0.41）如果char或unsigned char陣列的內容 被複制回對象的陣列，該對象隨後應保持其原始 值。

# define N sizeof (T) 
char buf[N]; 
T obj ; // obj initialized to its original value 
std :: memcpy (buf , & obj , N); // between these two calls to std::memcpy, 
           // obj might be modified 
std :: memcpy (& obj , buf , N); // at this point, each subobject of obj of 
           // scalar type holds its original value 

Answer 1

試想擁有一些指針這樣的緩衝類：

class Abc { 
    public: 
    int* data; 
    size_t n; 
    Abc(size_t n) 
    { 
     this->n = n; 
     data = new int[n]; 
    } 

    // copy constructor: 
    Abc(const Abc& copy_from_me) 
    { 
     n = copy_from_me.n; 
     data = new int[n]; 
     memcpy(data, copy_from_me.data, n*sizeof(int)); 
    } 
    Abc& operator=(const Abc& copy_from_me) 
    { 
     n = copy_from_me.n; 
     data = new int[n]; 
     memcpy(data, copy_from_me.data, n*sizeof(int)); 
     return *this; 
    } 

    ~Abc() 
    { 
     delete[] data; 
    } 
} ; 

如果你只是MEMCOPY它的實例之一，你會得到兩個實例指向到同一個緩衝區。如果您在一個實例中修改數據，則會在另一個實例中修改數據。

這意味着你並沒有真正將它克隆到兩個獨立的類中。而且，如果你刪除了這兩個類，那麼緩衝區會從內存中釋放兩次，從而崩潰。 所以這個類必須定義一個拷貝構造函數，你必須使用構造函數來拷貝它。

Answer 2

嘗試按位複製std::shared_ptr<>。你可能會發現你的程序經常會在你的臉上爆炸。

你會遇到這個問題，任何類的複製構造函數做一個比特明智的副本以外的東西。在std::shared_ptr<>的情況下，它將複製指針，但不會增加引用計數，因此您最終將盡早釋放共享對象及其引用計數，然後在複製的shared_ptr嘗試減少釋放時炸掉引用計數。

---

UPDATE：有人指出，這並不完全回答這個問題，這是公平的，因爲我主要是針對抄襲的shared_ptr到shared_ptr的想法，shared_ptr不爲char []，然後再返回。但是，這個原則依然成立。

如果你按位拷貝一個shared_ptr到一個char []，給shared_ptr分配一個不同的值，然後將char []複製回來，最終結果可能是泄漏一個對象並雙重刪除另一個，即UB。

POD也可能發生這種情況，但這是程序邏輯中的一個錯誤。只要程序能夠理解並容納這樣的事件，按位拷貝回等同於修改過的shared_ptr的POD將是完全有效的。這樣做對於std :: shared_ptr通常不起作用。

Answer 3

假設例如您正在編寫String類。該類的任何實例都應該包含一個指向某些動態分配的數組的指針。如果你memcopy這樣一個實例，那麼這兩個指針是平等的。一個字符串的任何修改都會影響另一個字符串。

Answer 4

一般來說，問題是對象不僅引入數據，還引入行爲。

通過複製數據手工我們可以打破對象，它可以依靠拷貝構造函數的內在行爲。

一個很好的例子是任何共享或唯一指針 - 通過複製它，我們打破了「交易」，我們與一流的製作時，我們使用它。

不管複製過程是語義正確與否，這樣做背後的想法是錯誤的，違反了對象的編程範式。

示例代碼：

/** a simple object wrapper around a pthread_mutex 
*/ 
class PThreadMutex 
{ 
    public: 
    /** locks the mutex. Will block if mutex is already locked */ 
    void lock(); 

    /** unlocks the mutex. undefined behavior if mutex is unlocked */ 
    void unlock(); 

    private: 
    pthread_mutex_t m_mutex; 

}; 

/** a simple implementation of scoped mutex lock. Acquires and locks a Mutex on creation, 
* unlocks on destruction 
*/ 
class ScopedLock 
{ 
    public: 
    /** constructor specifying the mutex object pointer to lock 
    * Locks immediately or blocks until lock is free and then locks 
    * @param mutex the mutex pointer to lock 
    */ 
    ScopedLock (PThreadMutex* mutex); 

    /** default destructor. Unlocks the mutex */ 
    ~ScopedLock(); 

    /** locks the mutex. Will block if mutex is already locked */ 
    void unlock(); 


    private: 

    PThreadMutex* m_mutex; 

    // flag to determine whether the mutex is locked 
    bool m_locked; 

    // private copy constructor - disable copying 
    ScopedLock(ScopedLock &mutex) { (void)mutex; /* to get rid of warning */ }; 

}; 

如果複製ScopedLock類，手動解鎖，然後恢復初始值和執行構造另一個解開它會導致一個未定義的行爲（或至少EPERM錯誤的析構函數）。

Answer 5

C++ 11 note：問題中的引用是規則的一個相當舊的版本。由於C++ 11，要求是平凡能夠複製比POD弱得多。

---

memcpy可以從任何對象使用。你得到一個對象的按位圖像。

如果對象不是POD，則圖像不能使用，好像它是同一類型與原始對象，這是因爲壽命規則要求初始化首先完成。

在這種情況下，圖像只是一堆字節。這可能仍然有用，例如，隨着時間的推移檢測對象的內部表示的變化，但只有對字節有效的操作（比如兩個圖像之間的比較）纔是合法的，而不是需要原始類型的對象的操作。