[Sobrecarga de operadores] Explicación de sobre código

[Doommarine_Maxi]

¡Hola a todos!, soy yo de vuelta y vuelvo a quitarles un poco de tiempo para pedirles ayuda con un código que he escrito para practicar sobrecarga de operadores.

Como casi todos los que recién inician en el manejo serio de clases, mi primer clase es de una cadena, si, poco original.

Código C++:

#include <iostream>
#include <stdio.h>
#include <ctype.h>
#include <string.h>
 
using namespace std;
 
/*Clase Cadena*/
 
class Cadena
{
    public:
        Cadena(); /*Constructor default*/
        Cadena(const char*); /*Sobrecarga de constructor con parametro puntero a char (array) constante*/
        Cadena &operator=(const Cadena&); /*Sobrecarga de Operador = con parametro Cadena mediante referencia y constante*/
        Cadena &operator=(const char*); /*Sobrecarga de Operador = con parametro puntero a char (array) constante*/
        Cadena operator+(const Cadena&); /*Sobrecarga de Operador + con parametro Cadena mediante referencia y constante*/
        Cadena operator+(const char*); /*Sobrecarga de Operador + con parametro puntero a char (array) constante*/
        //~Cadena() { delete [] cad; }; //Este destructor me generaba problemas en ejecución
        void Mostrar() { cout << cad << endl; } 
    private:
        char* cad; /*Puntero a cadena que va a funcionar como un array*/
};
 
Cadena::Cadena()
{
    /*En caso default de declaración de cadena el valor de cad es nulo*/
    cad = NULL;
}
Cadena::Cadena(const char* cadena)
{
    /*Asigno el valor de cadena a cad*/
    this->cad = new char[strlen(cadena)+1]; /*Reservo a un espacio de la memoria equivalente a la cantidad de
    caracteres en la cadena parametro más 1 para el caracter nulo que marca el final de cadena*/
    strcpy(this->cad, cadena);
}
 
/*La función sobrecarga de operator= en tipo de dato Cadena devuelve la dirección de la memoria
del valor que da como retorno esta función*/
Cadena &Cadena::operator=(const Cadena &CadC) 
{
    if (this == &CadC)
        return *this;
    if (!CadC.cad)
        return *this;
 
    delete [] this->cad;
    this->cad = new char[strlen(CadC.cad)+1];
    strcpy(this->cad, CadC.cad);
    return *this; /*Devulevo el valor de la cadena actual a la que le asigne el "cad" de CadC
    , este valor luego, debido a &Cadena::..., pasa en realidad la dirección de memoria de *this, que es this*/
}
 
Cadena &Cadena::operator=(const char* C)
{
    if (!C)
        return *this;
 
    delete [] this->cad;
    this->cad = new char[strlen(C)+1];
    strcpy(this->cad, C);
    return *this;
}
 
/*En estas funciones, la sobrecarga del operador+ esta el problema del desbordamiento al usar
la propiedad del destructor de cadena para liberar la memoria reservada por "cad"*/
Cadena Cadena::operator+(const Cadena &CadC)
{
    if (!CadC.cad)
        return *this;
    Cadena temp;    
    temp.cad = new char[strlen(CadC.cad)+strlen(this->cad)+1];
    strcpy(temp.cad, this->cad);
    strcat(temp.cad, CadC.cad);
 
    return temp;
}
Cadena Cadena::operator+(const char *C)
{
    if (!C)
        return *this;
 
    Cadena temp;    
    temp.cad = new char[strlen(C)+strlen(this->cad)+1];
    strcpy(temp.cad, this->cad);
    strcat(temp.cad, C);
 
    return temp;
}
 
int main()
{
    Cadena H("Hola mundo");
    Cadena *J;
    Cadena *K;
    K = &H;
            
    J = new Cadena[3];
    J[0] = "Hola ";
    J[1] = "mis ";
    J[2] = "Amigos.";
    
    for (int x=0; x < 3; x++) J[x].Mostrar();
 
    H.Mostrar();
    H = "Hola a todos";
    H.Mostrar();
    H = H + (H + " Chau");
    H.Mostrar();
 
    *K = J[0] + J[1] + J[2];
    H.Mostrar();
 
    delete [] J;
    
    return 0;
}
 

Me gustaría que me puedan ayudar a saber cual es el error que cometo en la sobrecarga del operador+ en tipo de clase Cadena, que tal es el problema que si activo el destructor se genera un error durante la ejecución.

Muchas gracias, también me gustaría, y esto es opcional y se los agradecería mucho, si me pudieran decir si esta bien comentado mi código, o si estoy cometiendo algún error al interpretar las referencias o los punteros.