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

< Programación en C++

← Streams Desarrollo Orientado a Objetos →

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

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 de forma 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.

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
dirigirnos 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.

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.

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 una lista compuesta de datos, donde para
referirnos a uno de ellos emplearemos un número para indicar la posición del mismo 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 |
|------|

Array bidimensional
Un 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 )

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' };

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 variablei 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
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>
#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

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 carácter 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 caracterNULL, ya que esto lo hace el compilador automáticamente.

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 carácter 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 carácter 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 carácter ( 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 carácter ( 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;

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 clasecstring, que no debe confundirse con la<string.h>.

Nota:Como el Dev-C++ ya esta descontinuado, es recomendable usar

alguno de los siguientes IDE:

Netbeans: Si usas Windows, debes descargar de aqui el

MinGWhttps://sourceforge.net/projects/mingw/files/latest/download el cual
incluye el compilador g++. Al instalar, solo debes marcar:

mingw-developer-toolkit
mingw32-base
mingw32-gcc-g++
msys-base

Luego Installation > Update Catalogue

Y finalmente, debemos configurar la variable de entorno.

 Instrucciones de como configurar variable de entorno:
https://www.java.com/es/download/help/path.xml

En el paso de editar la variable de entorno, edita el PATH con la siguiente

ruta C:\MinGW\bin

PD: Si es en Windows 7, debe agregar ; al final de la ultima linea del PATH

y colocar la ruta establecida.

Visual Studio

Eclipse

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.

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.

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.

← Streams Arriba Desarrollo Orientado a Objetos →

Obtenido de «https://es.wikibooks.org/w/index.php?
title=Programación_en_C%2B%2B/Arrays_y_cadenas_de_texto&oldid=338944
»

Se editó esta página por última vez el 27 oct 2017 a las 02:41.

El texto está disponible bajo laLicencia Creative Commons Atribución-CompartirIgual 3.0

; pueden aplicarse términos
adicionales. Véase Términos de uso para más detalles.