Código de C/Visual C - clase string

Imágen de perfil

clase stringgráfica de visualizaciones


C/Visual C

Publicado el 09 de Agosto del 2005 por Xavi
7.950 visualizaciones desde el 09 de Agosto del 2005. Una media de 14 por semana
Sencilla clase String, para la gestión de cadenas.

Programado con GNU/g++-4.0

Versión 1

Publicado el 09 de Agosto del 2005gráfica de visualizaciones de la versión: Versión 1
7.951 visualizaciones desde el 09 de Agosto del 2005. Una media de 14 por semana
estrellaestrellaestrellaestrellaestrella
estrellaestrellaestrellaestrella
estrellaestrellaestrella
estrellaestrella
estrella

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
#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;
}



Comentarios sobre la versión: Versión 1 (0)


No hay comentarios
 

Comentar la versión: Versión 1

Nombre
Correo (no se visualiza en la web)
Valoración
Comentarios

http://lwp-l.com/s1199