ndice

Cadenas....
2
Fundamentos de
cadenas
.2
Funciones de manejo de
cadenas
3
Definicin de estructura....
..6
Inicializacin de estructuras.
..6
Utilizacin de estructura....
..8
Fuentes de
informacin
..10

CADENAS
Cadena de caracteres. Una cadena en C++ es un conjunto de caracteres, o valores de
tipo "char", terminados con el carcter nulo. Internamente se almacenan en posiciones
consecutivas de memoria en forma de arreglo.
En programacin, una cadena de caracteres, palabras, ristra de caracteres o frase
(string, en ingls) es una secuencia ordenada (de longitud arbitraria, aunque finita) de
elementos que pertenecen a un cierto lenguaje formal o alfabeto anlogas a una
frmula o a una oracin. En general, una cadena de caracteres es una sucesin de
caracteres (letras, nmeros u otros signos o smbolos). Si no se ponen restricciones al
alfabeto, una cadena podr estar formada por cualquier combinacin finita de los
caracteres disponibles (las letras de la 'a' a la 'z' y de la 'A' a la 'Z', los nmeros del '0'
al '9', el espacio en blanco ' ', smbolos diversos '!', '@', '%', etctera).
En este mismo mbito, se utilizan habitualmente como un tipo de dato predefinido,
para palabras, frases o cualquier otra sucesin de caracteres. En este caso, se
almacenan en un vector de datos, o matriz de datos de una sola fila (array, en ingls).
Las cadenas se pueden almacenar fsicamente:
seguidas;
enlazados letra a letra.
Generalmente los caracteres se guardan uno a continuacin de otro para fines de
eficiencia en el acceso.
Un caso especial de cadena es la que contiene cero caracteres. A esta cadena se la
llama cadena vaca; en teora de autmatas, es comn representarla por medio de la
letra griega epsilon.

FUNDAMENTOS DE CADENAS
Los caracteres son bloques de construccin fundamentales para los programas fuente.
Un programa puede contener constantes de carcter. Una constante de carcter es un
valor int representado por un carcter entre comillas sencillas. El valor de una
constante de carcter es el valor entero del carcter en el conjunto de caracteres de la
mquina.
Por ejemplo, 'z' representa el valor entero de z, y '\n' representa el valor entero de una
nueva lnea.

Una cadena es un conjunto de caracteres tratados como una sola unidad. Una cadena
puede incluir letras, dgitos y varios caracteres especiales como +, -, *, y $. En C, las
literales de cadena, o constantes de cadena, se escriben dentro de comillas dobles de
la siguiente manera:
Juan P. Prez (un nombre)
99999 de Eje Central (la direccin de una calle)
En C, una cadena es un arreglo de caracteres, los cuales terminan con el carcter nulo
('\0'). Se accede a una cadena mediante un apuntador a su primer carcter. El valor de
una cadena es la direccin del primer carcter. As, en C, es apropiado decir que una
cadena es un apuntador, de hecho, un apuntador al primer carcter de la cadena. En
este sentido, las cadenas son como arreglos, debido a que un arreglo tambin es un
apuntador al primer elemento.
Un arreglo de caracteres o una variable de tipo char * puede inicializarse con una
cadena en la definicin. Las definiciones char color[] = azul; const char *ptrColor =
azul; inicializan una variable con la cadena azul. La primera definicin crea un
arreglo de 5 elementos, color, que contiene los caracteres 'a', 'z', 'u', 'l' y '\0'. La
segunda variable crea una variable apuntador, ptrColor, que apunta a la cadena azul
en algn lugar de la memoria.
La definicin del arreglo anterior tambin podra escribirse como char color[] = {'a', 'z',
'u', 'l', '\0'};
Cuando se define un arreglo para que contenga una cadena, ste debe ser lo suficiente
grande para almacenar la cadena y su carcter de terminacin nulo. La definicin
anterior determina automticamente el tamao del arreglo, basndose en el nmero
de inicializaciones de la lista de inicializacin ('a', 'z', 'u', 'l', '\0').
No almacenar suficiente espacio en un arreglo de caracteres para almacenar el
carcter nulo que termina una cadena, es un error.
Si una cadena es ms grande que el arreglo de caracteres en el cual se va a
almacenar, los caracteres ms all del final del arreglo sobrescribirn los datos
siguientes en la memoria del arreglo.
Una cadena puede almacenarse en un arreglo, por medio de scanf. Por ejemplo, la
siguiente instruccin almacena el arreglo de caracteres palabra [20]:
scanf( %s, palabra );
La cadena que introduce el usuario se almacena en palabra. Observe que palabra es un
arreglo, el cual es, por supuesto, un apuntador, de modo que no necesitamos un & con
el argumento palabra. La funcin scanf leer caracteres hasta encontrar un espacio, un
tabulador, un indicador de nueva lnea o de fin de archivo. Observe que la cadena no
debe ser mayor que 19 caracteres para dejar espacio suficiente para el carcter de
terminacin nulo. Para un arreglo de caracteres que se imprimir como una cadena, el
arreglo debe contener el carcter de terminacin nulo.
La cadena de caracteres est definida como un arreglo de caracteres, debido a que el
nombre de un arreglo es la direccin de memoria del primer elemento del arreglo, por
lo que si se iguala el nombre del arreglo al nombre de un puntero, a este puntero se le
puede aplicar aritmtica de punteros (ver apunte Punteros) para poder desplazarse
entre los datos del arreglo.

Las funciones scanf() y printf() reconocen a los espacios introducidos con la barra
espaciadora como finales de cadena. Esto puede solucionarse usando las funciones
gets() y puts() incluidas en la librera ctype.h

FUNCIONES DE MANEJO DE CADENAS

Aunque C no incorpora en su definicin operadores para el manejo de cadenas de
caracteres, todo compilador de C proporciona una librera estndar (string.h) con
funciones para facilitar su utilizacin. Destacar algunas de ellas:
strcpy: La funcin strcpy se encuentra en la biblioteca <string.h> y se utiliza para
copiar una cadena de caracteres (fuente) en el lugar que ocupaba otra (destino). Esta
copia es destructiva, o sea, que todos los caracteres que estaban en la cadena destino
desaparecen, aunque la cadena destino fuera ms larga que la cadena fuente .La
cadena destino se pone como primer argumento de la funcin y la cadena fuente como
segundo. Vamos a verlo con un ejemplo.
#include<stdio.h>
#include<string.h>
int main()
{
char texto1[]="corta";
char texto2[]="mediana";
char texto3[]="larguisima";
strcpy(texto2,texto1);
printf("%s\n",texto2);
strcpy(texto2,texto3);
printf("%s\n",texto2);
getch();
return 0;
}
strcat: En el programa anterior vimos que la funcin strcpy es destructiva, pero hay
otra funcin en la librera <string.h> que copia una cadena (fuente) en otra (destino)
sin destruir sta, es decir, que copia una cadena detrs de la otra esta funcin es
conocida como strcat. Vamos a hacer un ejemplo:
#include<stdio.h>
#include<string.h>
int main()
{
char texto1[]="Don Pepito";
char texto2[]=" y ";
char texto3[]="Don Jose";printf("%s\n",texto1);
strcat(texto1,texto2);
printf("%s\n",texto2);
strcat(texto1,texto3);
printf("%s\n",texto2);
getchar();

return 0;
}
strlen: esta funcin devuelve el total (entero) de caracteres que conforman una
cadena (excluyendo el carcter nulo \0). Vamos a hacer un ejemplo:
#include <stdio.h>
#include <string.h>
#include <conio.h>
#define MAXLON 80
int main(void)
{
char a[MAXLON+1];
int longitud;
clrscr();
printf ("Introduce una cadena (max. %d caracteres): ", MAXLON);
scanf("%s",&a);
longitud = strlen(a);
printf ("\nLongitud de la cadena: %d\n", longitud);
getch();
return 0;
}
strcmp: strcmp (abreviatura de ((string comparison))). La funcin strcmp recibe dos
cadenas, a y b, devuelve un entero. El entero que resulta de efectuar la llamada
strcmp(a, b) codifica el resultado de la comparacin: es menor que cero si la cadena a
es menor que b, es 0 si la cadena a es igual que b, y es mayor que cero si la cadena a
es mayor que b. Naturalmente, menor significa que va delante en orden alfabtico, y
mayor que va detrs.
#include <stdio.h>
#include <string.h>
int main()
{
char s1[6] = "Abeja";
char s2[6] = "abeja";
int i;
printf( "s1=%s\t", s1 );
printf( "s2=%s\n", s2 );
i = strcmp( s1, s2 );
printf( "s1 es " );
if( i < 0 ) printf( "menor que" );
else if( i > 0 ) printf( "mayor que" );
else printf( "igual a" );
printf( " s2\n" );
return 0;
}
Otras Funciones tiles para operar cadenas de caracteres.

No slo string.h contiene funciones tiles para el tratamiento de cadenas. En ctype.h se

encuentran unas funciones que permiten hacer cmodamente preguntas acerca de los
caracteres, como si son maysculas, minsculas, dgitos, etc:
- isalnum(carcter): devuelve cierto (un entero cualquiera distinto de cero) si carcter
es una letra o dgito, y falso (el valor entero 0) en caso contrario.
- isalpha(carcter): devuelve cierto si carcter es una letra, y falso en caso contrario.
- isblank(carcter): devuelve cierto si carcter es un espacio en blanco o un tabulador.
- isdigit(carcter) devuelve cierto si carcter es un digito, y falso en caso contrario.
- isspace(carcter): devuelve cierto si carcter es un espacio en blanco, un salto de
lnea, un retorno de carro, un tabulador, etc., y falso en caso contrario.
- islower(carcter): devuelve cierto si carcter es una letra minscula, y falso en caso
contrario.
- isupper(carcter): devuelve cierto si carcter es una letra mayscula, y falso en caso
contrario.
- toupper(carcter): devuelve la mayscula asociada a carcter, si la tiene; si no,
devuelve el mismo carcter.
- tolower(carcter): devuelve la minscula asociada a carcter, si la tiene; si no,
devuelve el mismo carcter.

DEFINICION DE ESTRUCTURA
Una estructura es un tipo de dato compuesto que permite almacenar un conjunto de
datos de diferente tipo. Los datos que contiene una estructura pueden ser de tipo
simple (caracteres, nmeros enteros o de coma flotante etc.) o a su vez de tipo
compuesto (vectores, estructuras, listas, etc.).
A cada uno de los datos o elementos almacenados dentro de una estructura se les
denomina miembros de esa estructura y stos pertenecern a un tipo de dato
determinado.
La programacin estructurada es un paradigma de programacin orientado a mejorar
la claridad, calidad y tiempo de desarrollo de un programa de computadora, utilizando
nicamente subrutinas y tres estructuras: secuencia, seleccin (if y switch) e iteracin
(bucles for y while), considerando innecesario y contraproducente el uso de la
instruccin de transferencia incondicional (GOTO), que podra conducir a "cdigo
espagueti", que es mucho ms difcil de seguir y de mantener, y era la causa de
muchos errores de programacin.
Surgi en la dcada de 1960, particularmente del trabajo de Bhm y Jacopini, y una
famosa carta, La sentencia goto considerada perjudicial, de Edsger Dijkstra en 19682
y fue reforzado tericamente por el teorema del programa estructurado, y
prcticamente por la aparicin de lenguajes como ALGOL con adecuadas y ricas
estructuras de control.

Recordemos que una estructura define un tipo de dato, no una variable, lo que significa
que no existe reserva de memoria cuando el compilador est analizando la estructura.
Posteriormente habr que declarar variables del tipo definido por la estructura para
poder almacenar y manipular datos.

INICIALIZACION DE ESTRUCTURAS
Se ha sealado que, al igual que las matrices, las estructuras pueden iniciarse, incluso
en el mismo punto de su declaracin, con una lista de iniciadores entre corchetes { }
separados por comas [1], uno para cada miembro de la estructura. Por ejemplo, la
sentencia:
struct Cliente {int i; char str[20]; double d;} s = {33, "Pepe Lopez", 3.14 };
Declara una estructura Cliente compuesta por un entero; un array de 20 caracteres, y
un doble. Tambin inicia una estructura s como perteneciente al tipo Cliente con
valores concretos en cada campo.
En estructuras o uniones con duracin automtica, el iniciador debe ser alguno de los
siguientes: Una lista de inicializadores constantes (tambin se permiten expresiones
con sizeof) Ejemplo:
struct punto {int x; int y;} p1 = {1, 2};
Una sola expresin con una estructura de tipo compatible. En este caso, el valor inicial
del objeto es el de la expresin. Ejemplo:
struct punto p2 = p1;
En este caso, (suponiendo los valores anteriores) sera: p2.x == 1 y p2.y == 2
Los miembros complejos de listas de iniciadores. Por ejemplo matrices, pueden
inicializarse con expresiones adecuadas incluidas en bloques de corchetes anidados.
Por ejemplo:
struct Pesadas {
int tiket;
int pesos[5];
} s = { 150, {10, 45, 0, 78, 20}};
Si la lista de inicializadores contenidos entre los corchetes { } es menor que los
miembros de la estructura, el resto de los miembros es inicializado implcitamente
siguiendo las mismas reglas que los objetos con duracin esttica.
Las estructuras, al igual que las matrices, almacenan sus miembros de forma contigua,
razn por la cual, como veremos ms adelante, se les pueden aplicar punteros y una
cierta aritmtica. Por la misma razn, se pueden crear matrices de estructuras e
incluso estructuras de matrices (sus miembros son matrices). Conceptualmente, estas
ltimas no se diferencian gran cosa de las matrices de matrices (a no ser en la

notacin de acceso a sus miembros). Tambin se puede calcular su tamao en bytes

con la expresin sizeof, aunque a este respecto debe tenerse en cuenta algunas
posibles discrepancias respecto a los valores "tericos", debidas a las alineaciones
internas realizadas por el compilador, que se comentan.
Se ha dicho que los miembros de estructuras pueden ser de cualquier tipo, incluso
otras estructuras ( 4.5.6 Matrices de estructuras). Sin embargo, existen varias
limitaciones, sobre todo las que se opongan al principio anterior. Por ejemplo, la
declaracin que sigue conduce a un error:
struct str {int x; char * psch = "Hola";}; // Error!
La razn ya expuesta, que en la definicin de un tipo no pueden realizarse
asignaciones, tiene su base en el comentario anterior. En efecto: en "Constantes de
cadena" ( 3.2.3f), se indic que ante la expresin char* psch = "Hola";, el compilador
debe crear una matriz de caracteres "Hola\0"; almacenarlo en algn sitio, y asignar a
una variable tipo puntero a carcter psch (direccin del primer elemento de la matriz).
Esto conducira a que no se podra garantizar que los miembros estuvieran
ntegramente en la estructura.
La expresin anterior sera admisible con una modificacin del tipo:
char* psch = "Hola";
struct str {int x; char* psch;};
Una alternativa es efectuar la asignacin en una variable concreta (en POO diramos en
una instancia de la clase str):
char * psch = "Hola";
struct str {int x; char * psch;}; // define el tipo de estructura str
struct str strA;
strA.psch = psch;

// declara strA estructura tipo str

nbsp; // asigna valor

Podemos efectuar una comprobacin de la asignacin:

printf("%s\n", strA.psch); // -> Hola
Hay que hacer hincapi en que el miembro strA.psch (puntero a carcter) apunta ahora
a la direccin de una zona de memoria donde est almacenada la cadena "Hola\0",
direccin que coincide con la indicada por el puntero [2] psch. Si cambiamos el valor de
psch, el del miembro no se ver afectado, lo que podemos comprobar aadiendo estas
sentencias:
char * psch = "Lola";
printf("%s\n", strA.psch);

// -> Hola

El resultado evidencia que la cadena "Hola" sigue existiendo en alguna posicin de

memoria y es accedida mediante strA.psch.

Se habra obtenido un resultado distinto si en vez de las dos sentencias anteriores

modificamos directamente la posicin de memoria donde est alojada la cadena
"Hola". Lo hacemos mediante:
*psch = 'L'; *(psch+3) = 'o';
printf("%s\n", strA.psch);

// -> Lolo

Observe que el parntesis *(psch+3) es necesario, ya que *psch+3 es interpretado

como (*psch)+3 = 'K'. Con lo que el intento de asignacin 'K' = 'o' produce un error del
compilador: No es un Lvalue. Ya vimos que el miembro a la izquierda de una asignacin
debe ser un Lvalue ( 2.1.5).
Una variante de la declaracin anterior, sealada es la siguiente:
struct str {int x; char * psch;}; // define el tipo de estructura str
struct str strA = {1, "Hola"};
printf("%s\n", strA.psch);

// declara e inicia strA

// salida: Hola

La situacin final es anloga a la all expuesta; el resultado es una cadena "Hola\0"

almacenada en algn sitio y un puntero a carcter strA.psch apuntando a ella, como
miembro de la estructura strA. Podemos comprobarlo modificando el contenido de las
posiciones de memoria que alojan la cadena mediante:
*strA.psch = 'L'; *(strA.psch+3) = 'o';
printf("%s\n", strA.psch);

// -> Lolo

UTILIZACION DE ESTRUCTURA
Al contrario que los arrays, las estructuras nos permiten agrupar varios datos, que
mantengan algn tipo de relacin, aunque sean de distinto tipo, permitiendo
manipularlos todos juntos, usando un mismo identificador, o cada uno por separado.
Las estructuras son llamadas tambin muy a menudo registros, o en ingls records.
Tienen muchos aspectos en comn con los registros usados en bases de datos. Y
siguiendo la misma analoga, cada objeto de una estructura se denomina a menudo
campo, o field.
Sintaxis:
struct [<identificador>] {
[<tipo> <nombre_objeto>[,<nombre_objeto>,...]];
} [<objeto_estructura>[,<objeto_estructura>,...];
El identificador de la estructura es un nombre opcional para referirse a la estructura.
Los objetos de estructura son objetos declarados del tipo de la estructura, y su
inclusin tambin es opcional. Sin bien, an siendo ambos opcionales, al menos uno de
estos elementos debe existir.

En el interior de una estructura, entre las llaves, se pueden definir todos los elementos
que consideremos necesarios, del mismo modo que se declaran los objetos.
Las estructuras pueden referenciarse completas, usando su nombre, como hacemos
con los objetos que ya conocemos, y tambin se puede acceder a los elementos
definidos en el interior de la estructura, usando el operador de seleccin (.), un punto.
Una vez definida una estructura, es decir, si hemos especificado un nombre para ella,
se puede usar igual que cualquier otro tipo de C++. Esto significa que se pueden
declarar ms objetos del tipo de estructura en cualquier parte del programa. Para ello
usaremos la forma normal de declaracin de objetos, es decir:
[struct] <identificador> <objeto_estructura>
[,<objeto_estructura>...];
En C++ la palabra struct es opcional en la declaracin de objetos, al contrario de lo
que sucede en C, en el que es obligatorio usarla.
Ejemplo:
struct Persona {
char Nombre[65];
char Direccion[65];
int AnyoNacimiento;
} Fulanito;
Veamos un ejemplo sencillo para ilustrar el uso de estructuras.
Forma 1:
struct Punto {
int x, y;
Punto() {x = 0; y = 0;} // Constructor
} Punto1, Punto2;
Forma 2:
struct Punto {
int x, y;
Punto(); // Declaracin del constructor
} Punto1, Punto2;
// Definicin del constructor, fuera de la estructura
Punto::Punto() {
x = 0;
y = 0;
}