[SOLUCIONADO] [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.

[amchacon]

Los comentarios los veo correctos. Aunque en un código profesional habría que poner la definición y implementación en archivos distintos (por cuestión de orden y mantener el encapsulamiento).

Los operadores + no son correctos porque estás creando nuevas clases sobre la marcha. Has perdido la referencia de la clase original, tienes que devolver la misma clase.

Yo lo haría directo:

Código C++:

Cadena Cadena::operator+(const char *C)
{
    if (!C)
        return *this;
   
    delete [] cad; // Borramos la antigua cadena
    cad = new char[strlen(C)+strlen(this->cad)+1]; // creamos una nueva
    strcat(cad,C);
 
    return *this;
}
 

Nota: No es necesario usar el puntero this para acceder al miembro cad de la clase.

[Doommarine_Maxi]

Iniciado por amchacon

Los comentarios los veo correctos. Aunque en un código profesional habría que poner la definición y implementación en archivos distintos (por cuestión de orden y mantener el encapsulamiento).

Los operadores + no son correctos porque estás creando nuevas clases sobre la marcha. Has perdido la referencia de la clase original, tienes que devolver la misma clase.

Yo lo haría directo:

Código C++:

Cadena Cadena::operator+(const char *C)
{
    if (!C)
        return *this;
   
    delete [] cad; // Borramos la antigua cadena
    cad = new char[strlen(C)+strlen(this->cad)+1]; // creamos una nueva
    strcat(cad,C);
 
    return *this;
}
 

Nota: No es necesario usar el puntero this para acceder al miembro cad de la clase.

Muchas gracias por tu comentario amchacon, me gustaría consultarte una ultima cosa.

Veras, recien estoy empezando a manejarme con punteros de una manera, digamos "más prolija". He visto que has usado la función new para reservar más espacio en la memoria dinámica para datos tipo char. La consulta aquí es que...

Al utilizar new, ¿Simplemente se reserva más espacio en la memoria sin afectar a los datos que hay en ella?, es decir, ¿Todos los datos que hay en "cad" siguen intactos con la diferencía que ahora tengo más espació en los arrays verdad?, ¿como un "realloc"?.

Otra cosa, delete [], lo que hace es eliminar la reserva de espació en la memoria y new genera nueva reserva de espació en la memoria dinamica... ¿Todo sin afectar a los datos que había en esos espacios de memoria verdad?.

Simplemente tengo esa duda al ver que usaste delete, luego new y luego concatenaste a cad

[amchacon]

Iniciado por Doommarine_Maxi

Al utilizar new, ¿Simplemente se reserva más espacio en la memoria sin afectar a los datos que hay en ella?, es decir, ¿Todos los datos que hay en "cad" siguen intactos con la diferencía que ahora tengo más espació en los arrays verdad?, ¿como un "realloc"?.

Otra cosa, delete [], lo que hace es eliminar la reserva de espació en la memoria y new genera nueva reserva de espació en la memoria dinamica... ¿Todo sin afectar a los datos que había en esos espacios de memoria verdad?.

Simplemente tengo esa duda al ver que usaste delete, luego new y luego concatenaste a cad

No haber, el sistema de memoria es más sencillo que eso. Digamos que sería un malloc simplificado.

El operador new le pide al sistema operativo que le reserve memoria. Si la petición es aceptada, obtienes la dirreción donde se encuentra tu memoria reservada.

De modo que:

Código C++:

char* Ejemplo; // puntero
 
Ejemplo = new char[10]; //Pido al sistema operativo 10 bytes
 
Ejemplo = new char[15]; // Vuelvo a pedirle el sistema operativo 15 bytes, obtengo otra dirreción diferente
 

Esto es un error grave, puesto que ahora mismo tenemos reservada 25 bytes de memoria pero solo tenemos la dirreción de los ultimos 15 bytes, los otros 10 bytes son "memoria perdida" (al sistema operativo le consta como reservada pero como no tenemos su dirreción no podemos usarla).

Si además tenemos datos importantes en esos 10 bytes, también los perderemos (new no maneja los datos, simplemente pide memoria al SO y te devuelve su dirreción).

Por eso en el código, he usado primero delete[] para liberar la memoria anterior y despues he hecho una nueva petición... Aunque ahora que me doy cuenta, se me ha olvidado guardar los datos antes (en una cadena auxiliar por ejemplo).



La verdad esque si voy a redimensionar en tiempo de ejecución. No usaría el delete/new sino la clase vector. Su sintaxis es:

Código C++:

vector<tipo> nombre; // Declaración del vector
nombre.push_back(elemento); // Añadir un elemento al vector
 

Ejemplo:

Código C++:

#include <vector>
 
//...
 
vector<int> Numeros; // Vector de enteros
int Buffer;
cout<<"Introduzca elementos hasta que encuentre el cero";
 
do
{
  cin>> Buffer;
  nombre.push_back(Buffer); // añado el numero al vector
} while (Buffer != 0);
 
// Los muestro por pantalla
 
for (int i = 0; i < Numeros.size();i++) // Numeros.size() devuelve el tamaño del vector
   cout<<Numeros[i];
 
Numeros.resize(5); // Modificamos el tamaño del vector, si el vector es más pequeño que cinco se añadirán elementos nulos, en caso contrario se suprimirán los ultimos elementos.
 
vector<int> Cosa;
Cosa = Numeros; // operador = sobrecargado
 
Cosa.pop_back(); // Eliminando el ultimo elemento
 
if (Numeros > Cosa) // Operador > sobrecargado
  cout<<"Hecho";
 

Para más información:
http://www.cplusplus.com/reference/vector/vector/