Question

在下面的代码中，我没有得到

使MyClass :: ~MyClass（）析构函数私有化的使用/原因/好处？
由于析构函数是私有的，所以最后如何调用析构函数。

 // myclass.h
#include <iostream>
class MyClass {
public:
    static MyClass& GetInstance();
    void Display();
private:
    MyClass();
    virtual ~MyClass();
};

MyClass::MyClass() {
    std::cout << "Constructor " << std::endl;
}

MyClass::~MyClass() {
    std::cout << "Destructor" << std::endl;
}

MyClass& MyClass::GetInstance() {
    static MyClass _instance;
    return _instance;
}

void MyClass::Display() {
    std::cout << "Hello" << std::endl;
}

// main.cpp

#include "myclass.h"
#include <iostream>
int main() {

    MyClass::GetInstance().Display(); //case1



    std::cout << "main finished!" << std::endl;

    return 0;
}

//输出

Constructor
Hello
Destructor

//编辑

如果我公开我的类的Contructor并删除GetInstance（）函数。

> MyClass obj;
> obj.Display();

然后弹出以下错误

1>e:\programs\cpp_test\src\main.cpp(38): error C2248: 'MyClass::MyClass' : cannot access private member declared in class 'MyClass'
1>          e:\programs\cpp_test\static_single_test.h(11) : see declaration of 'MyClass::MyClass'
1>          e:\programs\cpp_test\static_single_test.h(6) : see declaration of 'MyClass'
1>e:\programs\cpp_test\src\main.cpp(38): error C2248: 'MyClass::~MyClass' : cannot access private member declared in class 'MyClass'
1>          e:\programs\cpp_test\static_single_test.h(12) : see declaration of 'MyClass::~MyClass

问题：如何通过c ++处理静态大小写？是不是凌驾于私人行为？

Answer 1

在共享库的情况下可能出现限制应用程序可以执行的操作。

使用共享库的应用程序使用导出的函数来获取对象的句柄，并且必须显式调用另一个导出的函数来销毁该对象。

它就像一个有充分理由的使用合同 - 它存在于DLL / so的堆或数据段中 - 因此应用程序无法解除分配它）。

反过来导出的函数会调用你的静态函数。类似的东西：

extern "C" __declspec(dllexport) MyClass* CreateMyClass() {
    return &MyClass::GetInstance();
}


extern "C" __declspec(dllexport) void     DestroyMyClass(MyClass* handle) {
    delete handle; // assumes destructor isn't private. 
    // if destructor is private, you can't use delete since it calls the destructor, which is .... private!
    handle->Destroy(); // A member function that calls the private destructor
}

MyClass::Destroy() {
    if (it_is_safe_to_destroy_the_class)
        ~Destroy();
}

但是，然后Destroy（）成员函数应该是公共的，所以这个例子不够好（它是私有构造函数的一个很好的理由）

基本上，您希望通过私有构造和/或销毁限制您的类的用户可以执行的操作。您通过静态变量“创建”实例，而不是它们，并允许它们仅使用功能（公共接口），而不是其他任何东西。同样，当你认为安全时，你会销毁它。

（编辑：我之前的回答主要集中在私人建筑上，所以我为私人破坏添加了一个更明确的例子）

Answer 2

类本身及其所有private的所有成员函数（包括static个）都可以访问friend析构函数。所以，显然，如果你只想要那些能够销毁一个对象，那么制作析构函数private是可行的。

Answer 3

您发布的类看起来像一个单例，这个类只允许每次执行一次实例化。构造函数和析构函数都是私有的，以确保您可以通过GetInstance调用访问对象实例的唯一方法，该调用以确保只存在一个实例的方式编写。

C++ Singleton design pattern

通过实现，实例是一个静态对象，这意味着当程序清理静态对象时它将被删除，基本上是在程序结束时。

What is the lifetime of a static variable in a C++ function?

Answer 4

是的，有理由在私有部分中创建析构函数。它将创建C ++类
其对象只能动态分配。

你可以举个例子：

 #include <iostream>
  using namespace std;

  // A class whose object can only be dynamically created
  class Test
     {
      private:
        ~Test() { cout << "Destroying Object\n"; }
      public:
        Test() { cout << "Object Created\n"; }
        friend void destructTest(Test* );
 };

// Only this function can destruct objects of Test
  void destructTest(Test* ptr)
    {
delete ptr;
cout << "Object Destroyed\n";
}

  int main()
     {
   /* Uncommenting following following line would cause compiler error */
   // Test t1;

 // create an object
     Test *ptr = new Test;

 // destruct the object to avoid memory leak
destructTest(ptr);

return 0;
    }

如果您尝试创建一个静态对象编译器会出错

使用析构函数私有

4 个答案: