| Contacto | Chat | Foro |__
  
 
Principal Hoja de Vida Universidad Artículos Programas Descargas
 

Clase para manejo de cadenas de caracteres


PROG00016 - C/C++

Esta clase, permite la manipulación sencilla de cadenas de caracteres en C++ e ilustra la construcción de operadores de asignación, concatenación y condición para este tipo de datos. Incluye funciones 'amigas' para implementar los operadores inserción y extracción y la posibilidad de 'casting' a entero.

// Librerías y definiciones

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

typedef unsigned short ushort;

// Definición de la clase

class Cadena
{
   char *D;
   ushort L;

   public:
   Cadena (void);                       

   Cadena (ushort pL);
   Cadena (Cadena& pC);
   ~Cadena (void);                      

   Cadena& operator = (const char* pC); 

   Cadena& operator = (Cadena& pC);     
   Cadena& operator + (Cadena& pC);     
   Cadena& operator + (const char* pC); 
   int operator == (Cadena& pC);        
   int operator > (Cadena& pC);         
   int operator >= (Cadena& pC);
   int operator < (Cadena& pC);
   int operator <= (Cadena& pC);
   int operator != (Cadena& pC);
   operator int(void);                  

                                        
   friend ostream& operator << (ostream& pS,Cadena& pC);
   friend istream& operator >> (istream& pS,Cadena& pC);
};

// Constructores y destructor

// Inicialización sin argumentos
Cadena::Cadena (void)
{
   L= 0;
   D= NULL;
}
 

// Inicialización indicando longitud máxima de la cadena
Cadena::Cadena (ushort pL)
{
   L= pL;
   D= new char[L];
}
 

// Inicialización a partir de una cadena preexistente
Cadena::Cadena (Cadena& pC)
{
   L= pC.L;
   D= new char[L];
   strcpy(D,pC.D);
}
 

// Destrucción de la instancia
Cadena::~Cadena (void)
{
     if (D!=NULL)
          delete D;
}

// Operadores de asignación

// Asignación de una cadena de caracteres (char *)
Cadena& Cadena::operator = (const char* pC)
{

   // Verifica la longitud de la cadena a asignar y comprueba que
   // haya espacio suficiente
   // Si el espacio no es suficiente, redimensiona

   if (L<(ushort)strlen(pC))    

   {                            
      L= strlen(pC)+1;        
      if (D!=NULL)            
         delete D;
      D= new char[L];
   }
   // Copia una cadena en otra
   strcpy(D,pC);                

   return *this;
}
 

// Asignación del contenido de otro objeto de tipo cadena
// Opera similar al anterior, con la diferencia de que el parámetro
// es de tipo Cadena

Cadena& Cadena::operator = (Cadena& pC)
{
   if (L<(ushort)strlen(pC.D))
   {
      L= strlen(pC.D)+1;
      if (D!=NULL)
         delete D;
      D= new char[L];
   }
   strcpy(D,pC.D);

   return *this;
}
 

// Operadores de concatenación

// Concatena dos objetos de tipo cadena
Cadena& Cadena::operator + (Cadena& pC)
{
   // Variable temporal para concatenación
   static Cadena* T= NULL;    

   if (T==NULL)
      T= new Cadena(strlen(D)+strlen(pC.D)+1);

   // Copia la primera cadena en el destino
   strcpy(T->D,D);        

   // Concatena la segunda cadena en el destino
   strcat(T->D,pC.D);     


   // Retorna la cadena concatenada
   return *T;             

}
 

// Concatena un objeto de tipo cadena con una cadena de caracteres (char *)
Cadena& Cadena::operator + (const char* pC)
{
   static Cadena* T= NULL;

   if (T==NULL)
      T= new Cadena(strlen(D)+strlen(pC)+1);

   strcpy(T->D,D);
   strcat(T->D,pC);

   return *T;
}

// Operadores condicionales

// Compara dos objetos de tipo cadena
// Para que dos cadenas sean iguales, deben contener los mismos caracteres
// De no ser así, las cadenas son diferentes
// Para que una cadena sea mayor que otra, debe estar situada 'alfabeticamente'
// luego de la otra. De no ser así, es menor

nt Cadena::operator == (Cadena& pC)
{
   if (strcmp(D,pC.D)==0)
      return 1;

   return 0;
}

int Cadena::operator > (Cadena& pC)
{
   if (strcmp(D,pC.D)>0)
      return 1;

   return 0;
}

int Cadena::operator >= (Cadena& pC)
{
   if (strcmp(D,pC.D)>=0)
      return 1;

   return 0;
}

int Cadena::operator < (Cadena& pC)
{
   if (strcmp(D,pC.D)<0)
      return 1;

   return 0;
}

int Cadena::operator <= (Cadena& pC)
{
   if (strcmp(D,pC.D)<=0)
      return 1;

   return 0;
}

int Cadena::operator != (Cadena& pC)
{
   if (strcmp(D,pC.D)!=0)
      return 1;

   return 0;
}

// Conversión a entero (casting)

// Este método permite convertir el contenido de un objeto de tipo Cadena a int
Cadena::operator int (void)
{
   return atoi(D);
}

// Operadores para manejo de flujos (streams)

// Operador de inserción
// Se implementa como función amiga
// Permite enviar información a un flujo de salida
ostream& operator << (ostream& pS,Cadena& pC)
{
   if (pC.D!=NULL)
      pS << pC.D;

   return pS;
}

// Operador de extracción
// Se implementa como función amiga
// Permite recibir información de un flujo de entrada

istream& operator >> (istream& pS,Cadena& pC)
{
   // Variable temporal
   char T[128];       

   // Lee información del flujo de entrada
   pS >> T;           

   // Dimensiona la cadena de acuerdo a la información leída
   if (pC.L<strlen(T))

   {                  
      if (pC.D!=NULL)
         delete pC.D;
      pC.L= strlen(T)+1;
      pC.D= new char[pC.L];
      strcpy(pC.D,T);
   }

   return pS;
}

Advertencia
Aunque no he escatimado esfuerzos en cuanto a proveer aplicaciones e información confiable y veraz, sin embargo no puedo garantizar que esté totalmente libre de errores; por esa razón, no asumo responsabilidad alguna por las consecuencias que se deriven de su empleo.




7-Zip

Descarga Adobre Reader

Descargar programa
  Copyright 2005 | Ramón Medina | Todos los derechos reservados | Última Actualización: Agosto del 2008 | webmaster@ramonmedina.name