Constructores

Son funciones que permiten construir o inicializar objetos. Se caracterizan por:

  1. Debe tener necesariamente el mismo nombre que la clase.

  2. Puede haber más de un constructor.

  3. No devuelven valores.

  4. Puede definirse como inline.

Destructores

Son funciones que limpian el almacenamiento asignado al objeto. Se caracteriza por:

  1. El nombre del Destructor es el mismo que el de la clase, pero estará precedido por el signo ~.

  2. Sólo puede haber un Destructor por clase.

  3. Un Destructor no tiene argumentos ni devuelve valores.

  4. El sistema ejecuta el Destructor automáticamente cuando se sale del ámbito del objeto. No se puede ejecutar al igual que los constructores.

Ejemplo:

Grabar este ejemplo 

/************************************************
Programa Orientado a Objetos para evaluar una expresión en postfijo
Versión 2: usando constructores y destructores
************************************************/

#include<iostream.h>
#include<iomanip.h>
#include<string.h>
#include<stdlib.h>

const char BLANCO = 32;
const char END_ST = '\0';

class ClasePila
{    int tamano;
     float * cima;
     float * stack;
   public:
     ClasePila(void);      //Constructor por defecto
     ClasePila(int);       //Constructor
     ~ClasePila(void);     //Destructor
     int EstaVacia(void);
     int EstaLlena(void);
     void Push (float);
     void Pop (float &);
};

ClasePila::ClasePila(int t)
{    tamano = t;
     stack = new float[t];
     cima =NULL;
}

ClasePila::ClasePila(void)
{    tamano = 100;
     stack = new float[tamano];
     cima =NULL; 
}

ClasePila::~ClasePila(void)

{    tamano = 0;
     delete stack;
     delete cima;
}

int ClasePila::EstaVacia(void)
{    return cima==NULL ? 1: 0; 
}

int ClasePila::EstaLlena(void)
{    return cima==(stack+tamano) ? 1: 0; 
}

void ClasePila::Push (float valor)
{    if (cima==NULL) cima = stack;
     else  cima++ ;
     *cima = valor;
}

void ClasePila::Pop (float &valor)
{    valor = *cima;
     if (cima==stack) cima=NULL;
     else cima--; 
}

/***********************************************/

class ClaseCadena
{    char exp[100];
     char *st;
   public:
     void Leete(void);
     char *DamePalabra(void);
     int EstasVacia(void);
};

void ClaseCadena::Leete(void)
{    cin.getline(exp,100);
     st=exp;
}

char* ClaseCadena::DamePalabra(void)
{    char* p=st, *palabra;
     int i;
     for (i=0; *(st+i)==BLANCO; i++, p++);
         st=p;
     for (i=0; *(st+i)!=BLANCO && *(st+i)!=END_ST; i++, p++);
         palabra = new char[int(p-st) +1];
     for (i=0; st != p; *(palabra + i++)= *(st++) );
         *(palabra+i)=END_ST;
     return palabra;
}

int ClaseCadena::EstasVacia(void)
{    return *st == END_ST? 1 :0; 
}

/***********************************************/

int EsOperando(char *);
float opera(float, char *, float);

/***********************************************/

void main (void)
{    ClaseCadena Expresion;
     //ClasePila Pila;
     ClasePila Pila(10);
     char *dato;
     float Resultado;

     cout << "Ingrse expresión : ";
     Expresion.Leete();
     while (!Expresion.EstasVacia())
     {    dato= (Expresion.DamePalabra());
          if (EsOperando(dato) )
               Pila.Push(atof(dato));
          else
          {    float Dato1, Dato2;
               Pila.Pop(Dato1);
               Pila.Pop(Dato2);
               Pila.Push(opera(Dato2,dato,Dato1));
          }
     }
     Pila.Pop(Resultado);
     cout << "Resultado = " << Resultado << endl;
}

int EsOperando(char *op)
{    switch (*op)
     {    case '+': case '-': case '*': case '/': return 0;
          default : return 1;
     }
}

float opera(float d1, char *op, float d2)
{    switch (*op)
     {    case '+': return d1+d2;
          case '-': return d1-d2;
          case '*': return d1*d2;
          case '/': return d1/d2;
          default : return 0;
     }
}

Constructores con argumentos por Defectos

Permiten reducir el número de constructores con un objeto.

Ejemplo:

Grabar este ejemplo 

/*Ejemplo de uso de constructores con argumentos por defecto*/

#include<iostream.h>

class ClFecha
{    int dd;
     int mm;
     int aa;
   public:
     ClFecha(int D=1, int M=1, int A=1999);

     /*Es en este lugar donde se colocan los argumentos con sus
     respectivos valores por defecto*/

     void DefineD(int);
     void DefineM(int);
     void DefineA(int);
     char *Dame(void);
};

ClFecha::ClFecha(int D, int M, int A)
{    dd=D; mm=M; aa=A; 
}

void ClFecha::DefineD(int D)
{    dd=D;
}

void ClFecha::DefineM(int M)
{    mm=M; 
}

void ClFecha::DefineA(int A)
{    aa=A; 
}

char *ClFecha::Dame(void)
{    char *F;
     int aux;

     F=new char[11];
     F[0]='0'+ dd/10;  F[1]='0'+ dd%10;  F[2]='/';

     F[3]='0'+ mm/10;  F[4]='0'+ mm%10;  F[5]='/';

     F[6]='0'+ aa/1000; aux=aa%1000;
     F[7]='0'+ aux/100; aux %= 100;
     F[8]='0'+ aux/10;
     F[9]='0'+ aux%10;
     F[10]=0;
     return F;
}

void main(void)
{    ClFecha Fecha1;
     ClFecha Fecha2(13);
     ClFecha Fecha3(13,5);
     ClFecha Fecha4(13,5,2000);

     cout <<"Sin argumentos :" << Fecha1.Dame() << endl;
     cout <<"Con 1 argumento : " << Fecha2.Dame() << endl;
     cout <<"Con 2 argumentos : " << Fecha3.Dame() << endl;
     cout << "Con 3 argumentos : " << Fecha4.Dame() << endl;
}

/*  Cuando se ejecuta el programa se obtiene:

     Sin argumentos   : 01/01/1999
     Con 1 argumento  : 13/01/1999
     Con 2 argumentos : 13/05/1999
     Con 3 argumentos : 13/05/2000

*/

Constructores de Copia

Es un constructor que crea un objeto a partir de otro ya existente. Este tipo de constructor tiene un solo argumento, el cual es una referencia constante a un objeto de la misma clase.

Ejemplo:

Grabar este ejemplo 

//Ejemplo del uso del Constructor de Copia

#include<iostream.h>

class ClFecha
{    int dd;
     int mm;
     int aa;
   public:
     ClFecha(int D=1, int M=1, int A=1900);
     ClFecha(const ClFecha &);    //Constructor de Copia

     void DefineD(int);
     void DefineM(int);
     void DefineA(int);
     char *Dame(void);
     void Aumenta(void);
};

ClFecha::ClFecha(int D, int M, int A)
{    dd=D; mm=M; aa=A; 
}

ClFecha::ClFecha(const ClFecha &F)
{    dd = F.dd;
     mm = F.mm;
     aa = F.aa;
}

void ClFecha::DefineD(int D)
{    dd=D; 
}

void ClFecha::DefineM(int M)
{    mm=M; 
}

void ClFecha::DefineA(int A)
{    aa=A; 
}

char *ClFecha::Dame(void)
{    char *F;
     int aux;

     F=new char[11];
     F[0]='0'+ dd/10;  F[1]='0'+ dd%10;  F[2]='/';
     F[3]='0'+ mm/10;  F[4]='0'+ mm%10;  F[5]='/';
     F[6]='0'+ aa/1000; aux=aa%1000;
     F[7]='0'+ aux/100; aux %= 100;
     F[8]='0'+ aux/10;
     F[9]='0'+ aux%10;
     F[10]=0;
     return F;
}

void ClFecha::Aumenta(void)
{    if (dd == 30)
     {    dd = 1;
          if (mm==12)
          {    mm = 1;
               aa++;
          }
          else
               mm++;
     }
     else
          dd++;
}

void main(void)
{    ClFecha Hoy;
     int D,M,A;

     cout << "Ingrese la fecha de hoy : ";
     cin >>  D >> M >> A;

     Hoy.DefineD(D);
     Hoy.DefineM(M);
     Hoy.DefineA(A);

     cout << "La fecha de hoy es: " << Hoy.Dame() << endl;

     ClFecha Mañana=Hoy;
     Mañana.Aumenta();

     cout << "La fecha de mañana es:" << Manana.Dame() << endl;
}


/*Cuando se ejecuta el programa se obtiene:

    Ingrese la fecha de hoy : 13 5 1999
    La fecha de hoy es : 13/05/1999
    La fecha de mañana es : 14/05/1999

*/

Volver a contenidos AtrásSiguiente