C++ 中的私有析构函数

访问修饰符为私有的析构函数称为私有析构函数。每当我们想防止对象被破坏时，我们可以将析构函数设为私有。

私有析构函数有什么用？

每当我们想控制类对象的销毁时，我们将析构函数设为私有。对于动态创建的对象，可能会发生您将指向对象的指针传递给函数并且该函数会删除该对象。如果对象在函数调用之后被引用，则引用将变得悬空。

预测以下程序的输出：

CPP

// CPP program to illustrate
// Private Destructor
#include 
using namespace std;
  
class Test {
private:
    ~Test() {}
};
int main() {}

上面的程序编译并运行良好。因此，我们可以说：创建私有析构函数不是编译器错误。

现在，你对下面的程序有什么看法？

CPP

// CPP program to illustrate
// Private Destructor
#include 
using namespace std;
  
class Test {
private:
    ~Test() {}
};
int main() { Test t; }

输出

prog.cpp: In function ‘int main()’:
prog.cpp:8:5: error: ‘Test::~Test()’ is private
    ~Test() {}
    ^
prog.cpp:10:19: error: within this context
int main() { Test t; }

上述程序编译失败。编译器注意到局部变量 't' 不能被破坏，因为析构函数是私有的。

现在，下面的程序呢？

CPP

// CPP program to illustrate
// Private Destructor
#include 
using namespace std;
  
class Test {
private:
    ~Test() {}
};
int main() { Test* t; }

上述程序运行良好。没有构造对象，程序只是创建了一个“Test *”类型的指针，所以没有任何东西被破坏。

接下来，下面的程序呢？

CPP

// CPP program to illustrate
// Private Destructor
#include 
using namespace std;
  
class Test {
private:
    ~Test() {}
};
int main() { Test* t = new Test; }

上面的程序也可以正常工作。当使用动态内存分配创建某些内容时，程序员有责任将其删除。所以编译器不会打扰。

在析构函数被声明为私有的情况下，也可以使用 malloc()函数创建类的实例。在下面的程序中也是如此。

CPP

// CPP program to illustrate
// Private Destructor
  
#include 
using namespace std;
  
class Test {
public:
    Test() // Constructor
    {
        cout << "Constructor called\n";
    }
  
private:
    ~Test() // Private Destructor
    {
        cout << "Destructor called\n";
    }
};
  
int main()
{
    Test* t = (Test*)malloc(sizeof(Test));
    return 0;
}

上面的程序也可以正常工作。但是，以下程序在编译中失败。当我们调用 delete 时，会调用析构函数。

CPP

// CPP program to illustrate
// Private Destructor
#include 
using namespace std;
  
class Test {
private:
    ~Test() {}
};
  
// Driver Code
int main()
{
    Test* t = new Test;
    delete t;
}

我们注意到，在上述程序中，当一个类具有私有析构函数时，只能创建该类的动态对象。以下是一种使用私有析构函数创建类并具有作为类友函数的方法。该函数只能删除对象。

CPP

// CPP program to illustrate
// Private Destructor
#include 
  
// A class with private destructor
class Test {
private:
    ~Test() {}
  
public:
    friend void destructTest(Test*);
};
  
// Only this function can destruct objects of Test
void destructTest(Test* ptr) { delete ptr; }
  
int main()
{
    // create an object
    Test* ptr = new Test;
  
    // destruct the object
    destructTest(ptr);
  
    return 0;
}

必读： C++ 中的构造函数可以是私有的吗？