Use of making destructor private

Question

In the code below, I am not getting the

1. use/reasons/benefits of making MyClass::~MyClass() destructor private?
2. Since the destructor is private, so how the destructor are getting called at the end.

 // 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;
}

//Output

Constructor
Hello
Destructor

// Edit

if I make the Contructor of my class public and remove the GetInstance() function.

> MyClass obj;
> obj.Display();

Then the following error pops up

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

'

Question: How making how static case is being handled by c++? Is is not overriding the private behaviour?

Answer 1

It might come up in the case of shared libraries to limit what an application can do.

The application using the shared library uses an exported function to get a handle to the object and has to explicitly call another exported function to destroy the object.

Its like a contract of usage with good reason - it exists in the DLL/so 's heap or data segment - so the application can't deallocate it).

That exported function in turn would call your static function. Something like:

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();
}

But, then the Destroy() member function ought to be public, so this example isn't good enough (it served as a good reason for private constructor)

Essentially, you want to limit what users of your class can do via private construction and/or destruction. You "create" the instance, not them, via a static variable and allow them to only use the functionality (public interface) and not anything else. Similarly, you destroy it when you deem it safe.

(Edit: My previous answer was focused towards private construction, so I added a more explicit example for private destruction)

Answer 2

A private destructor is accessible by all member functions (including static ones) of the class itself and all its friends. So, obviously, if you only want those to be able to destroy an object, then making the destructor private is the way to go.

Answer 3

The class you posted looks like a singleton, which is a class that is only allowed to be instanced once per execution. Both the constructor and destructor are made private, to make sure the only way you can access an instance of the object is via the GetInstance call, which is written in such a way as to ensure only one instance will exist.

C++ Singleton design pattern

With your implementation, the instance is a static object, which means it will be deleted when static objects are cleaned up by your program, basically when the program ends.

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

Answer 4

Yes, There is a reason to make the destructor in private section.It will create C++ class
whose objects can only be dynamically allocated.

you can take this example:

 #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;
    }

If you try to crate a static object compiler gives an error