#include <iostream>
#include <string>
using namespace std;
/*
* inicio de la clase String
*
* uso de una clase string
*/
class String
{ public:
//constructores
String();
String(const char * const);
//constructor de copia
String(const String &);
//destructor
~String();
//operadores sobrecargados
//operador [] que devuelve una referencia a char. Se utiliza en instrucciones como UnaCadena[3]='x'
char & operator[] (unsigned short offset);
//operador [] que devuelve un char. No modifica ningun valor "const"
char operator[] (unsigned short offset) const;
String operator+ (const String &);
void operator+= (const String &);
String & operator= (const String &);
//metodos generales
unsigned short GetLen() const
{return itsLen;} const char * GetString() const
{return itsString;} private:
//constructor privado, se utiliza unicamente desde alguna funcion interna de la clase
String (unsigned short);
//declaracion de variables
//contiene la cadena
char * itsString;
//contiene la longitud de la cadena
unsigned short itsLen;
};
//constructor predeterminados. Crea una cadena de 0 bytes
String::String()
{ //inicializamos la cadena
itsString=new char[1];
//colocamos como primera posicion de la cadena el final de linea
itsString[0]='\\0';
itsLen=0;
}
//convierte un array de caracteres en una cadena
String::String (const char * const cString)
{ //strlen=devuelve la longitud de una cadena, sin contar con el caracter nulo de terminacion.
itsLen=strlen(cString);
itsString=new char[itsLen+1];
//llenamos la cadena con el array recibido
for (unsigned short i=0;i<itsLen;i++)
itsString[i]=cString[i];
itsString[itsLen]='\\0';
}
//constructor de copia
//rhs es una referencia al mismo control String
String::String (const String & rhs)
{ itsLen=rhs.GetLen();
itsString=new char[itsLen+1];
for (unsigned short i=0;i<itsLen;i++)
itsString[i]=rhs[i];
itsString[itsLen]='\\0';
}
//destructor
String::~String()
{ delete [] itsString;
itsLen=0;
}
//operador [] sobrecargado
char & String::operator[] (unsigned short offset)
{ if(offset>itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
//operador [] sobrecargado
char String::operator[] (unsigned short offset) const
{ if(offset>itsLen)
return itsString[itsLen-1];
else
return itsString[offset];
}
//crea una cadena nueva al agregar a la cadena actual el contenido de rhs
String String::operator+ (const String & rhs)
{ unsigned short totalLen=itsLen+rhs.GetLen();
//utilizamos el constructor privado "String (unsigned short);"
String temp(totalLen);
unsigned short i;
for (i=0;i<itsLen;i++)
temp[i]=itsString[i];
for (unsigned short j=0;j<rhs.GetLen();j++,i++)
temp[i]=rhs[j];
temp[totalLen]='\\0';
return temp;
}
//crea una cadena nueva al agregar a la cadena actual el contenido de rhs. No devuelve nada, modifica el valor actual.
void String::operator+= (const String & rhs)
{ unsigned short totalLen=itsLen+rhs.GetLen();
//utilizamos el constructor privado "String (unsigned short);"
String temp(totalLen);
unsigned short i;
for (i=0;i<itsLen;i++)
temp[i]=itsString[i];
for (unsigned short j=0;j<rhs.GetLen();j++,i++)
temp[i]=rhs[i-itsLen];
temp[totalLen]='\\0';
//modificamos el valor actual de la variable
*this=temp;
}
//operador igual a
String & String::operator= (const String & rhs)
{ //this es una variable que se pasa ocula y hace referencia al lado derecho de la asignacion (a=b)
//comprovamos si el apuntador del lado derecho de la asignación (this) es igual a la misma referencia
// de memoria que el lado izquerdo de la asignacion.
if(this==&rhs)
return *this;
//eliminamos la referencia actual de la cadena
delete [] itsString;
//cogemos la nueva longitud
itsLen=rhs.GetLen();
itsString=new char[itsLen+1];
for (unsigned short i=0;i<itsLen;i++)
itsString[i]=rhs[i];
itsString[itsLen]='\\0';
return *this;
}
//constructor privado (ayudante), solo lo utilizan los metodos de la clase
// para crear una cadena nueva del tamaño requerido y llena de caracteres nulos.
//recibe el parametro 'len', que indica la longitud de la cadena a crear.
String::String (unsigned short len)
{ itsString=new char[len+1];
for (unsigned short i=0;i<=len;i++)
itsString[i]='\\0';
itsLen=len;
}
/*
* fin de la clase
*/
int main()
{ //utilizamos el constructor sobrecargado: "String(const char * const);" para crear la variable s1
String s1("prueba inicial"); cout << "s1\\t" << s1.GetString() << endl;
//creamos una variable temporal y la inicializamos
char * temp ="¡Hola mundo!";
//utilizamos el operador de copia: "String & operator= (const String &);"
s1=temp;
cout << "s1\\t" << s1.GetString() << endl;
//definimos una variable char de 30 caracteres
char tempDos[30];
//copiamos el texto "; ¡es grandioso estar aqui!" en la variable tempDos
strcpy(tempDos,"; ¡es grandioso estar aqui!");
cout << "tempDos\\t" << tempDos << endl;
s1+=tempDos;
cout << "s1\\t" << s1.GetString() << endl;
cout << "s1[3]\\t" << s1[3] << endl;
//modificamos el 4º caracter por una 'x'
s1[3]='x';
cout << "s1\\t" << s1.GetString() << endl;
//intentamos mostrar una posicion de la cadena superior a la largada real de la misma
//se utilizar el operador sobrecargado [] "char & String::operator[] (unsigned short);"
//devuelve la ultima posición de la cadena
cout << "s1[999]\\t" << s1[999] << endl;
String s2("otra cadena"); String s3;
//utilizamos el operador de suma "String operator+ (const String &);"
s3=s1+s2;
cout << "s3\\t" << s3.GetString() << endl;
String s4;
//utiliza el constructor "String(const char * const);"
s4="Porque trabaja esta funcion?";
cout << "s4\\t" << s4.GetString() << endl;
//una cadena char normal
char s5[]="¡Hola mundo!";
cout << endl << "s5\\t" << s5 << endl;
//modificamos el 4º valor de la cadena
s5[3]='x';
cout << "s5\\t" << s5 << endl;
//cualquier posición de memoria... puede contener cualquier caracter
cout << "s5[100]\\t" << s5[100] << endl;
return 0;
}
Crear cuenta
Comentarios sobre la versión: Versión 1 (0)
No hay comentarios