Arrays y cadenas de texto

Programación en C++/Arrays y cadenas de texto

← Streams Desarrollo Orientado a Objetos →

Contenido
[ocultar]

 1 Arrays y cadenas de texto

 2 Indices de un array
 3 Dimensiones de un array
o 3.1 Array unidimensional
o 3.2 Array bidimensional
 4 Declaración de arrays en C, C++
o 4.1 Iteraciones dentro de un array (vector)
o 4.2 Iteraciones dentro de un array (matriz)
 5 Cadenas de caracteres
o 5.1 La biblioteca string
 6 Cadenas en C++
 7 Arrays en C++

[editar] Arrays y cadenas de texto

Los arrays son usados extensamente por los programadores para contener listas de datos
en la memoria, por ejemplo, los datos almacenados en un disco suelen leerse y ponerse
dentro de un array con el objetivo de facilitar la manipulación de dichos datos, ya que
los datos en memoria pueden ser modificados, clasificados, marcados para su
eliminacion, etc. para luego ser reescritos al disco. Otro ejemplo podría ser el de un
menú de opciones que se desplegarán dentro de una ventana para que el usuario pueda
elegir una de éstas, en tales casos y cuando las opciones son numerosas, solamente se
ponen unas cuantas de ellas dentro de la ventana pero se le da al usuario la oportunidad
de poder subir y bajar a su antojo para ver el resto de opciones que, aunque no se vean
en la ventana, forman parte del menú o array de opciones.

Array:

Un array es un conjunto de datos del mismo tipo ordenados en forman líneal uno
después de otro. Los componentes de un array se han de referenciar por medio del
nombre del array y un índice de desplazamiento para indicar el componente deseado.

[editar] Indices de un array

Los índices son números que se utilizan para identificar a cada uno de los componentes
de un array. A modo de ejemplo, podemos pensar que los índices son como los números
de habitaciones de un hotel, es decir, para poder dirijirnos a un hotel específico es
necesario saber el nombre del mismo, luego, si queremos llegar a una habitación
específica de dicho hotel necesitaremos, además del nombre del hotel, el número de
habitación deseado.

[editar] Dimensiones de un array

De acuerdo a la forma en que se construye o declara un array, éste puede ser clasificado
como: unidimensional, bidimensional y multidimensional. Los arrays que se emplean
con mucha más frecuencia son los estructurados a manera de vector ( array
unidimensional ) y los estructurados a manera de matriz ( array bidimensional ), así,
aunque en C++ se pueden crear estructuras multidimensionales, en este capítulo solo
trataremos con vectores y matrices.

[editar] Array unidimensional

Una array uni-dimensional es aquel en donde los componentes son accesibles por medio
de uno y solamente un índice que apunte al componente requerido. Los arrays de este
tipo son conocidos también con el nombre de vectores. Conceptualmente, podemos
pensar en un array unidimensional como en una lista compuesta de líneas o filas en
donde para referinos a una de ellas emplearemos un número para indicar la posición de
la misma dentro de la lista. Por ejemplo, consideremos el caso de la tabla o array
VentaSemanal, la cual está pensada para registrar las ventas de cada uno de los días de
la semana. De manera conceptual podemos ver el array como se muestra a continuación:

Nota: en C++ los arrays están basados en 0 ( cero ), es decir, el primer elemento de un
array se indexa mediante el 0, y el índice para el último de los elementos es igual al
número de componentes menos uno.

array: VentaSemanal

+------+
| dato | <-- componente 0, ( fila 0 )
|------|
| dato | <-- componente 1, ( fila 1 )
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | ...
|------|
| dato | <-- componente 6, ( fila 6 )
|------|

Si en el array VentaSemanal queremos que el elemento 4 ( por ejemplo ) contenga el

valor de 8987 lo podemos lograr con la instrucción: VentaSemanal[4] = 8987; y el
estado del array sería:

array: VentaSemanal
+------+
| dato |
|------|
| dato |
|------|
| dato |
|------|
| dato |
|------|
| 8987 | <--- componente 4
|------|
| dato |
|------|
| dato |
|------|

[editar] Array bidimensional

Una array bi-dimensional es aquel en donde los componentes son accesibles por medio
de una pareja de índices que apunten a la fila y a la columna del componente requerido.
Los arrays de este tipo son conocidos también con el nombre de matrices.
Conceptualmente, podemos pensar en un array bidimensional como en una lista
compuesta de filas y columnas, en donde para referirnos a una de ellas emplearemos un
número para indicar la posición de fila y otro número para indicar la posición de la
columna del componente deseado. Por ejemplo, consideremos el caso de la tabla o array
VentaSemanaQ, la cual está pensada para registrar las ventas de cada uno de los días de
la semana por cuatro semanas, o sea, una tabla de 7 x 4 elementos. De manera
conceptual podemos ver el array como se muestra a continuación:

array: VentaSemanaQ

C O L U M N A S

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
F | dato | dato | dato | dato |
|------|------|------|------|
I | dato | dato | dato | dato |
|------|------|------|------|
L | dato | dato | dato | dato |
|------|------|------|------|
A | dato | dato | dato | dato |
|------|------|------|------|
S | dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
+------+------+------+------+
|
+---- componente ( 6, 3 )
Si en el array VentaSemanaQ queremos que el elemento de la fila 4, columna 3 ( por
ejemplo ) contenga el valor de 5000 lo podemos lograr con la instrucción:
VentaSemanaQ[4][3] = 5000; y el estado del array sería:

array: VentaSemanaQ

+--- componente ( 0, 0 )
|
+------+------+------+------+
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | 5000 | <-- componente ( 4, 3 )
|------|------|------|------|
| dato | dato | dato | dato |
|------|------|------|------|
| dato | dato | dato | dato |
+------+------+------+------+
|
+---- componente ( 6, 3 )

[editar] Declaración de arrays en C, C++

En C, C++ para declarar un array se emplea la sintaxis:

tipo identificador [tamaño] = { lista de inicialización } ;

donde,

 tipo se refiere al tipo de datos que contendrá el array. El tipo puede ser
cualquiera de los tipos estándar (char, int, float, etc.) o un tipo definido por el
usuario. Es más, el tipo del array puede ser de una estructura creada con: struct,
union y class.

 identificador se refiere al nombre que le daremos al array.

 tamaño es opcional e indica el número de elementos que contendrá el array. Si

un array se declara sin tamaño, el mismo no podrá contener elemento alguno a
menos que en la declaración se emplee una lista de inicialización.

 lista de inicialización es opcional y se usa para establecer valores para cada uno
de los componentes del array. Si el array es declarado con un tamaño específico,
el número de valores inicializados no podrá ser mayor a dicho tamaño.

Ejemplos:

int intA[5];
long longA[5] = { 1, 2, 3, 4, 5 };
char charA[3] = { 'a', 'b', 'c' };
[editar] Iteraciones dentro de un array (vector)

El termino Iterar se refiere al hecho de acceder (con el fin de leer o escribir) sobre cada
uno de los componentes de un array. Así, para poner un ejemplo reconsideremos el caso
de la tabla VentaSemanal (vista en una sección anterior), y que dicho sea de paso es un
array de 7 elementos de tipo double. Luego, vamos a mostrar como ejemplo un
programa completo en el cual se declara el array mencionado con valores inicializados,
que serán mostrados en pantalla y al final la suma de estos. Observe que la variable i
usada para iterar dentro del array va desde 0 hasta FILAS - 1 ( FILAS es el tamaño del
array ).

Nota: por motivos de simplificación el programa está escrito al estilo de C estándar. Sin
embargo puede ser compilado y ejecutado en un compilador de C++.

#include <stdio.h>
#include <stdlib.h>

#define FILAS 7

int main()
{
float ventas[FILAS] = {
123.50, 234.60, 345.45, 321.40, 345.00, 456.65, 0.0 };

float total = 0;
int i;

puts("Ventas de la semana");
puts("-------------------");

for (i=0; i<FILAS; i++) {

total += ventas[i];
printf( "%8.2f\n", ventas[i] );
}

puts("--------");
printf("%8.2f\n", total );

system("pause");
return 0;
}

Esta es la salida del programa:

Ventas de la semana
-------------------
123.50
234.60
345.45
321.40
345.00
456.65
0.00
--------
1826.60

[editar] Iteraciones dentro de un array (matriz)

Con el fin de leer o escribir sobre cada uno de los componentes de una matriz se deben
crear dos ciclos de iteración. Así, para poner un ejemplo reconsideremos el caso de la
tabla VentaSemanaQ (vista en una sección anterior), y que dicho sea de paso es un
array de 4 x 4 elementos de tipo double. Luego, vamos a mostrar como ejemplo un
programa completo en el cual se declara el array mencionado con valores inicializados,
que serán mostrados en pantalla y al final la suma de estos. Observe que en este caso se
utilizan dos variables, una para iterar sobre las filas y otra para iterar sobre las columnas
de la matriz.

#include <stdio.h>
#include <stdlib.h>
//hola
#define FILAS 7
#define COLS 4

int main()
{
float VentaSemanaQ[FILAS][COLS] = {
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
123.50, 234.60, 345.45, 321.40,
345.00, 456.65, 123.50, 234.60,
345.45, 321.40, 345.00, 456.65,
0.0, 0.0, 0.0, 0.0 };

float totales[COLS] = { 0.0, 0.0, 0.0, 0.0 };

float grantotal = 0;

int f, c, t = 0 ; /* indices para filas, columnas y totales */

puts("Ventas de cuatro semanas");

puts("------------------------");

for (f=0; f<FILAS; f++) {

for (c=0; c<COLS; c++) {
totales[c] += VentaSemanaQ[f][c];
printf("%8.2f ", VentaSemanaQ[f][c] );
}
puts("");
}

puts("--------------------------------------");
for (t=0; t<COLS; t++) {
printf("%8.2f ", totales[t] );
grantotal += totales[t];
}

printf("\n\nGran total: %10.2f\n", grantotal);

system("pause");
return 0;
}

Salida del programa:

Ventas de cuatro semanas

------------------------
123.50 234.60 345.45 321.40
 345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
123.50 234.60 345.45 321.40
345.00 456.65 123.50 234.60
345.45 321.40 345.00 456.65
0.00 0.00 0.00 0.00
--------------------------------------
1627.90 2025.30 1627.90 2025.30

Gran total: 7306.40

[editar] Cadenas de caracteres

En C, C++ las cadenas de caracteres no son más que arrays de caracteres, salvo que a
este tipo de arrays el compilador les da un tratamiento especial. Usted puede manipular
las cadenas de caracteres de la misma manera en que manipula cualquier otro tipo de
array, sin embargo, es preferible hacer uso de una librería estándar especialmente escrita
para manipulacion de cadenas de caracteres, me refiero a la librería <string.h> y que
viene incluida con todo compilador de C, C++.

Para comenzar y antes de ver algunas de las funciones de la mencionada librería,

tenemos los siguientes ejemplos:

1. char nombre[] = "Oscar";

2. char nombre2[] = { 'O', 's', 'c', 'a', 'r', '\0' };

 En el ejemplo 1 se está declarando la variable nombre como una cadena de

caracteres y cuyo contenido inicial es "Oscar".
 En el ejemplo 2 se está declarando la variable nombre2 como una cadena de
caracteres y cuyo contenido inicial es { 'O', 's', 'c', 'a', 'r', '\0' };.

En ambos casos el resultado es el mismo, es decir, al final se obtiene la misma cadena,

pero usted debe poner atención al hecho de que toda cadena de caracteres en C, C++
debe terminar con el caracter NULL, que normalmente es igual a cero y se puede
escribir como '\0'. Ahora bien, cuando usted usa la sintaxis mostrada en el ejemplo 1 no
tiene que preocuparse por agregar el caracter NULL, ya que esto lo hace el compilador
automáticamente.

[editar] La biblioteca string

Los compiladores de C, C++ dan soporte a la biblioteca de funciones <string.h>, a la

que accede por medio de la directiva #include <string.h>. No veremos en detalle todas
las funciones contenidas en dicha biblioteca, y nos limitaremos a mostrar algunos
ejemplos de ciertas funciones importantes.

strlen(): Obtener longitud de cadenas

Sintaxis: size_t strlen(const char *s);

Comentarios: La función strlen() devuelve la longitud de la cadena s.
Ejemplo:

char *nombre = "Oscar E. Palacios";

cout << strlen(nombre) << endl;

strcpy(): Copiar cadenas

Sintaxis: char *stpcpy(char *dest, const char *src);

Comentarios: stpcpy copia la cadena src hacia dest, la función termina hasta
haber encontrado en src el caracter de terminación null.

Ejemplo:

char *nombre = "Oscar E. Palacios";

char copia[80];
strcpy(copia, nombre);
cout << copia << endl;

strcat(): Concatenar cadenas

Sintaxis: char *strcat(char *dest, const char *src);

Comentarios: strcat agrega la cadena src a dest, la función termina hasta haber
encontrado en src el caracter de terminación null.

Ejemplo:

char nombre[] = "Oscar E.";

char copia[80] = " Palacios";
strcat(copia, nombre);
cout << copia << endl;

strlwr(): Convertir a minúsculas.

Sintaxis: char *strlwr(char *dest);

Comentarios: strlwr convierte todos los caracteres alfabéticos ( 'A' .. 'Z' ) en dest
a sus correspondientes caracteres alfabéticos ( 'a' .. 'z' ).

Ejemplo:

char nombre[] = "Oscar E. Palacios";

strlwr(nombre);
cout << nombre << endl;

strupr(): Convertir a mayúsculas.

Sintaxis: char *strupr(char *dest);

Comentarios: strupr convierte todos los caracteres alfabéticos ( 'a' .. 'z' ) en dest a
sus correspondientes caracteres alfabéticos ( 'A' .. 'Z' ).

strchr(): Buscar caracter ( hacia adelante )

 Sintaxis: char *strchr(char *s, int c);
Comentarios: strchr busca en s el caracter c. La busqueda se lleva a cabo desde
el inicio hasta el final de s.
Regreso: si la operación es exitosa strchr regresa un puntero hacia la primera
ocurrencia de c en s, en caso contrario strchr regresa null.

Ejemplo:

char nombre[] = "Oscar E. Palacios";

char *p;

p = strchr(nombre, 'E');
if (p) {
cout << "nombre contiene a E" << endl;
cout << "indice = " << (p - nombre) << endl;
}
else cout << "E no está en nombre" << endl;

strrchr(): Buscar caracter ( hacia atras )

Sintaxis: char *strrchr(char *s, int c);

Comentarios: strchr busca en s el caracter c. La busqueda se lleva a cabo desde
el final hasta el inicio de s.
Regreso: si la operación es exitosa strchr regresa un puntero hacia la última
ocurrencia de c en s, en caso contrario strchr regresa null.

Ejemplo:

char nombre[] = "Oscar E. Palacios";

char *p;

p = strrchr(nombre, 'E');
if (p) {
cout << "nombre contiene a E" << endl;
cout << "indice = " << (p - nombre) << endl;
}
else cout << "E no está en nombre" << endl;

strstr(): Buscar subcadena

Sintaxis: char *strstr(const char *s1, char *s2);

Comentarios: strstr busca en s1 la subcadena s2. La búsqueda se lleva a cabo
desde el inicio hasta el final de s1.
Regreso: si la operación es exitosa strstr regresa un puntero hacia la primera
ocurrencia de s2 en s1, en caso contrario strstr regresa null.

Ejemplo:

char s[] = "Un barco de tristeza";

char *p;

p = strstr(s, "barco");
if (p) {
cout << "barco está en s" << endl;
cout << "indice = " << (p - s) << endl;
}
else cout << "barco no está en s" << endl;

[editar] Cadenas en C++

En la sección anterior descubrimos algunas funciones para trabajar con cadenas de
caracteres al estilo de C estándar, si bien no está de más tener tal conocimiento, también
es cierto que C++ es un lenguaje de programacíón orientado a objetos, de tal manera
que ciertos compiladores ( como el gcc, utilzado por Bloodshed Dev-C++ y otros tantos
entornos de desarrolo ) dan soporte a la clase cstring, que no debe confundirse con la
<string.h>.

Nota: Bloodshed Dev-C++ es un IDE (Editor con Depurador Integrado) para

programar en C++ en un ambiente gráfico para Windows, distibuido
gratuitamente bajo licencia GPL GNU y usted puede encontrarlo aquí:
www.bloodshed.net. Actualmente (febrero de 2008) se recomienda bajar la
versión Dev-C++ 4.9.9.2.
Nota:Como el Dev-c++ ya esta descontinuado, es recomendable usar su
estencion Wx Dev-C++ que esta actualmente activa y es recomendable para
muchos proyectos bajo el lenguaje C++, este programa tambien es licencia GPL,
podras descargarlo desde=wxdsgn.sourceforge.net, y encontraras informacion de
este aqui=es.wikipedia.org/wiki/WxDev-C%2B%2B.

Una de las ventajas que ofrece la clase cstring es que, a diferencia de las cadenas
estándar, ésta posee la capacidad de crecer o disminuir su tamaño en tiempo de
ejecución. Además, entre otras caracteristicas destacables, la clase string soporta
operaciones de asignación tales como: =, +, +=, etc.; y de comparación tales como: ==,
<=, etc.

Para tener una idea básica sobre las cadenas en C++ veamos el siguiente programa:

Nota: en el programa se debe de observar el uso del operador de asignación +=,

algo que no es posible hacer con las cadenas estándar.
// Ejemplo: demostración de la clase string
// Compilado y ejecutado con exito en Bloodshed Dev-C++
#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])

{
string s("Hola, ");
s += "cómo estan ustedes...";
cout << s << endl;
system("PAUSE");
return EXIT_SUCCESS;
}
Un estudio exhaustivo sobre la clase string requiere de un capítulo completo, ya que la
misma, según el manual de referencia de C++, posee aproximadamente 33 métodos y
unos 7 constructores; además de los atributos.

[editar] Arrays en C++

Así como C++ da aternativas elegantes para la manipulación de cadenas de caracteres,
también da el soporte para la manipulacíon de arrays dinámicos. Este tema será
ampliado en el capítulo Libreria de Plantillas Estándar STL, sin embargo para tener una
idea de lo que vendrá mostraremos aquí un ejemplo sencillo en donde se usará la clase
plantilla vector.

// Ejemplo: demostración de la clase vector

// Compilado y ejecutado con exito en Bloodshed Dev-C++
#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])

{
// creación de un vector de enteros
vector<int> v;

// metiendo datos en el vector

for (int x = 500; x<1000; x+=50)
v.push_back(x);

// desplegando los datos del vector

for (int x = 0; x < v.size(); x++)
cout << "v[" << x << "] = " << v[x] << endl;

system("PAUSE");
return EXIT_SUCCESS;

Array
#include <array>

template< class T, size_t N > struct array;

array es un pseudo-contenedor que ofrece el lenguaje C++ desde su estándar C++0x1).

Desde una perspectiva lógica es un envoltorio (wrapper) alrededor de los arrays de
tamaño constante (T[N]) en C++.

Esta estructura está definida para proveer todos los beneficios que se obtienen con una
perspectiva STL, incluyendo el hecho que el array conozca su propio tamaño,
iteradores, begin y end, , asignación, etc…; mientras preserva la efectividad de los
arrays con estilo C.

Tipos Miembro Definidos

 Member type Definition
value_type T
size_type size_t
difference_type ptrdiff_t
reference Allocator::reference
const_reference Allocator::const_reference
pointer T *
const_pointer const T *
iterator Random access iterator
const_iterator Constant random access iterator
reverse_iterator reverse_iterator<iterator>
const_reverse_iterator reverse_iterator<const_iterator>

Funciones Miembro
Acceso a los elementos

at accede al elemento en el índice especificado, con chequeo de rangos

operator[] accede al elemento especificado
front accede al primer elemento
back accede al último elemento
data acceso directo al array subyacente

Iteradores

begin, cbegin iterador al inicio del array

end, cend iterador al final del array
rbegin, crbegin iterador reverso al final del array
rend, crend iterador reveros al inicio del array

Capacidad

empty determina si el array está vacío

size retorna el número de elementos
max_size retorna el número máximo de elementos

Operaciones

fill llenar el array con un valor

swap intercambiar con otro array

Ejemplo de Uso
#include <array>
#include <algorithm>
#include <functional>
#include <iterator>
using namespace std;

srand (time (0));

array<short,6> miarray_1;
// el siguiente estilo de inicialización requiere soporte C++0x
array<short,4> miarray_2 = {-4, -2, 2, 4};
miarray_1.fill(18);
// sumar una cantidad al azar a todos los elementos y enviarlos al
array 1
transform(miarray_2.begin(), miarray_2.end(), miarray_1.begin(),
bind(plus<short>, _1, rand() ) // usamos la notación bind de C++0x o
bind2nd en C++
);
// mostrar la salida
copy(miarray_1.begin(), miarray_1.end(), ostream_iterator<short>(cout,
", "));