移動構造函數和const成員變量

Question

我喜歡const成員變量的想法，尤其是當我將C函數包裝到類中時。構造函數需要一個資源句柄（例如文件描述符），該句柄在整個對象生命週期內保持有效，並且析構函數最終關閉它。 （這是背後的想法，對吧？）

但與C++ 0x移動構造函數我遇到了問題。由於析構函數也被稱爲「未加載」的對象，我需要防止清理資源句柄。由於成員變量是const我沒有辦法分配值-1或INVALID_HANDLE（或等價值），以指示析構函數，它不應該做任何事情。

如果一個對象的狀態被移動到另一個對象時，有沒有方法可以調用析構函數？

例子：

class File 
{ 
public: 
    // Kind of "named constructor" or "static factory method" 
    static File open(const char *fileName, const char *modes) 
    { 
     FILE *handle = fopen(fileName, modes); 
     return File(handle); 
    } 

private: 
    FILE * const handle; 

public: 
    File(FILE *handle) : handle(handle) 
    { 
    } 

    ~File() 
    { 
     fclose(handle); 
    } 

    File(File &&other) : handle(other.handle) 
    { 
     // The compiler should not call the destructor of the "other" 
     // object. 
    } 

    File(const File &other) = delete; 
    File &operator =(const File &other) = delete; 
}; 

Answer 1

沒有，有沒有辦法做到這一點。我建議如果你真的接受了handle變量爲const，那麼你應該有一個非const標誌成員變量，它指示了銷燬是否應該做任何事情。

Answer 2

實現移動構造函數的典型方法是將被移動實例的成員置零或以其他方式使其失效（有關簡單示例，請參見MSDN）。因此，我認爲在這裏不要使用const，因爲它與移動語義的目標不兼容。

Answer 3

這就是爲什麼你不應該聲明所述成員變量const。 const成員變量通常不起任何作用。如果你不希望用戶改變FILE*，那麼不要爲它們提供這樣做的功能，並且如果你想阻止你偶然改變它，那麼標記你的函數const。但是，請勿自行創建成員變量const - 因爲那時您在開始使用移動或複製語義時遇到樂趣。

Answer 4

引用計數是解決您的問題的標準方法。考慮給你的班級添加引用計數;手動或使用現有的工具，如boost shared_ptr。

Answer 5

其實我今天也遇到過這個問題。不願意接受「不能做」 &「使用的shared_ptr /引用計數」，谷歌上搜索更多的，我想出了這個基類：

class Resource 
{ 
private: 
    mutable bool m_mine; 

protected: 
    Resource() 
    : m_mine(true) 
    { 
    } 

    Resource(const Resource&)  = delete; 
    void operator=(const Resource&) = delete; 

    Resource(const Resource&& other) 
    : m_mine(other.m_mine) 
    { 
     other.m_mine = false; 
    } 

    bool isMine() const 
    { 
     return m_mine; 
    } 
}; 

所有方法和構造的保護，你需要從繼承它使用它。注意可變字段：這意味着後裔可以是類中的一個常量成員。例如，

class A : protected Resource 
{ 
private: 
    const int m_i; 

public: 
    A() 
    : m_i(0) 
    { 
    } 

    A(const int i) 
    : m_i(i) 
    { 
    } 

    A(const A&& a) 
    : Resource(std::move(a )) 
    , m_i  (std::move(a.m_i)) // this is a move iff member has const move constructor, copy otherwise 
    { 
    } 

    ~A() 
    { 
     if (isMine()) 
     { 
      // Free up resources. Executed only for non-moved objects 
      cout << "A destructed" << endl; 
     } 
    } 
}; 

現在A的字段可以是const。請注意，我已經繼承了protected，所以用戶不會意外地將A轉換爲資源（或者非常樂意去破解它），但是A仍然不是最終的，因此您仍然可以繼承它（從Resource繼承的有效理由是例如具有分開的讀取和讀寫訪問）。這是極少數情況下保護繼承並不意味着您的設計有問題的情況之一;然而，如果你覺得難以理解，你可能只是使用公有繼承。

然後，假設你有一個struct X：

struct B 
{ 
    const A m_a; 
    const X m_x; 

    B(const A&& a, const X& x) // implement this way only if X has copy constructor; otherwise do for 'x' like we do for 'a' 
    : m_a(std::move(a)) 
    , m_x(   x ) 
    { 
    } 

    B(const B&& b) 
    : m_a(std::move(b.m_a)) 
    , m_x(std::move(b.m_x)) // this is a move iff X has move constructor, copy otherwise 
    { 
    } 

    ~B() 
    { 
     cout << "B destructed" << endl; 
    } 
}; 

需要注意的是B的領域也可以是常量。我們的移動構造函數是const。鑑於你的類型有適當的移動構造函數，任何堆分配的內存可以在對象之間共享。