Destructor privado en C++

Los destructores con el modificador de acceso privado se conocen como destructores privados. Siempre que queramos evitar la destrucción de un objeto, podemos hacer que el destructor sea privado.

¿Cuál es el uso de destructor privado?

Siempre que queramos controlar la destrucción de objetos de una clase, hacemos privado el destructor. Para los objetos creados dinámicamente, puede suceder que pase un puntero al objeto a una función y la función elimine el objeto. Si se hace referencia al objeto después de la llamada a la función, la referencia quedará colgando.

Prediga la salida de los siguientes programas: 

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

El programa anterior compila y funciona bien. Por tanto, podemos decir que: No es un error del compilador crear destructores privados. 

Ahora, ¿qué dices sobre el siguiente programa? 

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

Producción

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

El programa anterior falla en la compilación. El compilador nota que la variable local ‘t’ no se puede destruir porque el destructor es privado. 

Ahora, ¿qué pasa con el programa a continuación? 

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

El programa anterior funciona bien. No se está construyendo ningún objeto, el programa simplemente crea un puntero de tipo «Prueba *», por lo que no se destruye nada.

A continuación, ¿qué pasa con el siguiente programa? 

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

El programa anterior también funciona bien. Cuando se crea algo utilizando la asignación de memoria dinámica, es responsabilidad del programador eliminarlo. Entonces el compilador no se molesta. 

En el caso de que el destructor se declare privado, también se puede crear una instancia de la clase utilizando la función malloc(). Lo mismo se implementa en el siguiente programa. 

// CPP program to illustrate
// Private Destructor
  
#include <bits/stdc++.h>
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;
}

El programa anterior también funciona bien. Sin embargo, el siguiente programa falla en la compilación. Cuando llamamos a delete, se llama a destructor. 

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

Notamos en los programas anteriores que cuando una clase tiene un destructor privado, solo se pueden crear objetos dinámicos de esa clase. A continuación se muestra una forma de crear clases con destructores privados y tener una función como amigo de la clase. La función solo puede eliminar los objetos.  

// CPP program to illustrate
// Private Destructor
#include <iostream>
  
// 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;
}

Debe leer: ¿Puede un constructor ser privado en C++? 

Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.