Strings (Cadenas de texto)

Contenido del Captulo:

Introduccin
Las cadenas por dentro
Funciones de manejo de cadenas
o strlen
o strcpy
o strcat
o sprintf
o strcmp
Entrada de cadenas por teclado
o scanf
o gets
o Qu son los buffer y cmo funcionan
o getchar
Recorrer cadenas con punteros
Arrays de cadenas
Ordenar un array de cadenas
Ejercicios

Introduccin
Vamos a ver por fin cmo manejar texto con
mostrarlo por pantalla.

C, hasta ahora slo sabamos cmo

Para empezar dir que en C no existe un tipo string como en otros lenguajes. No
existe un tipo de datos para almacenar texto, se utilizan arrays de chars. Funcionan
igual que los dems arrays con la diferencia que ahora jugamos con letras en vez
de con nmeros.
Se les llama cadenas, strings o tiras de caracteres. A partir de ahora les
llamaremos cadenas.
Para declarar una cadena se hace como un array:
char texto[20];
Al igual que en los arrays no podemos meter ms de 20 elementos en la cadena.
Vamos a ver un ejemplo para mostrar el nombre del usuario en pantalla:
#include <stdio.h>
int main()
{
char nombre[20];
printf( "Introduzca su nombre (20 letras mximo): " );
scanf( "%s", nombre );
printf( "\nEl nombre que ha escrito es: %s\n", nombre );
}

Vemos cosas curiosas como por ejemplo que en el scanf no se usa el smbolo &. No
hace falta porque es un array, y ya sabemos que escribir el nombre del array es
equivalente a poner &nombre[0].
Tambin puede llamar la atencin la forma de imprimir el array. Con slo usar %s
ya se imprime todo el array. Ya veremos esto ms adelante.
Si alguno viene de algn otro lenguaje esto es importante: en
esto:

C no se puede hacer

int main()
{
char texto[20];
texto = "Hola";
}

Las cadenas por dentro

Es interesante saber cmo funciona una cadena por dentro, por eso vamos a ver
primero cmo se inicializa una cadena.
#include <stdio.h>
int main()
{
char nombre[] = "Gorka";
printf( "Texto: %s\n", nombre );
printf( "Tamao de la cadena: %i bytes\n", sizeof nombre );
}
Resultado al ejecutar:
Texto: Gorka
Tamao de la cadena: 6 bytes
Qu curioso! La cadena es "Gorka", sin embargo nos dice que ocupa 6 bytes.
Como cada elemento (char) ocupa un byte eso quiere decir que la cadena tiene 6
elementos. Pero si "Gorka" slo tiene 5! Por qu? Muy sencillo, porque al final de
una cadena se pone un smbolo '\0' que significa "Fin de cadena". De esta forma
cuando queremos escribir la cadena basta con usar %s y el programa ya sabe
cuntos elementos tiene que imprimir, hasta que encuentre '\0'.
El programa anterior sera equivalente a:
#include <stdio.h>
int main(int argc,char *argv[])
{
char nombre[] = { 'G', 'o', 'r', 'k', 'a', '\0' };
printf( "Texto: %s\n", nombre );
}
Aqu ya se ve que tenemos 6 elementos. Pero, Qu pasara si no pusiramos '\0' al
final?

#include <stdio.h>
int main()
{
char nombre[] = { 'G', 'o', 'r', 'k', 'a' };
printf( "Texto: %s\n", nombre );
}
En mi ordenador sala:
Texto: GorkaTamao de la cadena: 5 bytes
Pero en el tuyo despus de "Gorka" puede aparecer cualquier cosa. Lo que aqu
sucede es que no encuentra el smbolo '\0' y no sabe cundo dejar de imprimir.
Afortunadamente, cuando metemos una cadena se hace de la primera forma y el
se encarga de poner el dichoso smbolo al final.

Es importante no olvidar que la longitud de una cadena es la longitud del texto ms

el smbolo de fin de cadena. Por eso cuando definamos una cadena tenemos que
reservarle un espacio adicional. Por ejemplo:
char nombre[6] = "Gorka";
Si olvidamos esto podemos tener problemas.

Funciones de manejo de cadenas

Existen unas cuantas funciones el la biblioteca estndar de
cadenas:

C para el manejo de

strlen
strcpy
strcat
sprintf
strcmp

Para usar estas funciones hay que aadir la directiva:

#include <string.h>

strlen
Esta funcin nos devuelve el nmero de caracteres que tiene la cadena (sin contar
el '\0').
#include <stdio.h>
#include <string.h>
int main()
{
char texto[]="Gorka";
int longitud;

longitud = strlen(texto);
printf( "La cadena \"%s\" tiene %i caracteres.\n", texto,
longitud );
}
Crea tus propias funciones: Vamos a ver cmo se hara esta funcin si no
dispusiramos de ella. Si no te enteras cmo funciona consulta Recorrer cadenas
con punteros.
#include <stdio.h>
#include <string.h>
int main()
{
char texto[]="Gorka";
char *p;
int longitud=0;
p = texto;
while (*p!='\0')
{
longitud++;
printf( "%c\n", *p ); /* Mostramos la letra actual */
p++;
/* Vamos a la siguiente letra */
}
printf( "La cadena \"%s\" tiene %i caracteres.\n", texto,
longitud );
}
Para medir la longitud de la cadena usamos un puntero para recorrerla (el puntero
p). Hacemos que p apunte a texto. Luego entramos en un bucle while. La condicin
del bucle comprueba si se ha llegado al fin de cadena ('\0'). Si no es as suma 1 a
longitud, muestra la letra por pantalla e incrementa el puntero en 1 (con esto
pasamos a la siguiente letra).

strcpy
#include <string.h>
char *strcpy(char *cadena1, const char *cadena2);
Copia el contenido de cadena2 en cadena1. cadena2 puede ser una variable o una
cadena directa (por ejemplo "hola"). Debemos tener cuidado de que la cadena
destino (cadena1) tenga espacio suficiente para albergar a la cadena origen
(cadena2).
#include <stdio.h>
#include <string.h>
int main()
{
char textocurso[] = "Este es un curso de C.";
char destino[50];
strcpy( destino, textocurso );
printf( "Valor final: %s\n", destino );
}

Vamos a ver otro ejemplo en el que la cadena destino es una cadena constante
("Este es un curso de C") y no una variable. Adems en este ejemplo vemos que la
cadena origen es sustituida por la cadena destino totalmete. Si la cadena origen es
ms larga que la destino, se eliminan las letras adicionales.
#include <stdio.h>
#include <string.h>
int main()
{
char destino[50] = "Esto no es un curso de HTML sino un curso de
C.";
printf( "%s\n", destino );
strcpy( destino, "Este es un curso de C." );
printf( "%s\n", destino );
}

strcat
#include <string.h>
char *strcat(char *cadena1, const char *cadena2);
Copia la cadena2 al final de la cadena1.
#include <stdio.h>
#include <string.h>
int main()
{
char nombre_completo[50];
char nombre[]="Gorka";
char apellido[]="Urrutia";
strcpy(
strcat(
strcat(
printf(
}

nombre_completo, nombre );
nombre_completo, " " );
nombre_completo, apellido );
"El nombre completo es: %s.\n", nombre_completo );

Como siempre tenemos que asegurarnos que la variable en la que metemos las
dems cadenas tenga el tamao suficiente. Con la primera lnea metemos el
nombre en nombre_completo. Usamos strcpy para asegurarnos de que queda
borrado cualquier dato anterior. Luego usamos un strcat para aadir un espacio y
finalmente metemos el apellido.

sprintf
#include <stdio.h>
int sprintf(char *destino, const char *format, ...);
Funciona de manera similar a printf, pero en vez de mostrar el texto en la pantalla
lo guarda en una variable (destino). El valor que devuelve (int) es el nmero de
caracteres guardados en la variable destino.

Con sprintf podemos repetir el ejemplo de strcat de manera ms sencilla:

#include <stdio.h>
#include <string.h>
int main()
{
char nombre_completo[50];
char nombre[]="Gorka";
char apellido[]="Urrutia";
sprintf( nombre_completo, "%s %s", nombre, apellido );
printf( "El nombre completo es: %s.\n", nombre_completo );
}
Se puede aplicar a sprintf todo lo que vala para printf.

strcmp
#include <string.h>
int strcmp(const char *cadena1, const char *cadena2);
Compara cadena1 y cadena2. Si son iguales devuelve 0. Un nmero negativo si
cadena1 va antes que cadena2 y un nmero positivo si es al revs:
cadena1 == cadena2 -> 0
cadena1 > cadena2 -> nmero negativo
cadena1 < cadena2 -> nmero positivo

#include <stdio.h>
#include <string.h>
int main()
{
char nombre1[]="Gorka";
char nombre2[]="Pedro";
printf( "%i", strcmp(nombre1,nombre2));
}

Entrada de cadenas por teclado (scanf y gets)

scanf
gets
Qu son los buffer y cmo funcionan
getchar

scanf
Hemos visto en captulos anteriores el uso de scanf para nmeros, ahora es el
momento de ver su uso con cadenas.
Scanf almacena en memoria (en un buffer) lo que vamos escribiendo. Cuando
pulsamos ENTER (o Intro o Return, como se llame en cada teclado) lo analiza,
comprueba si el formato es correcto y por ltimo lo mete en la variable que le
indicamos.

#include <stdio.h>
#include <string.h>
int main()
{
char cadena[30];
printf( "Escribe una palabra: " );
fflush( stdout );
scanf( "%s", cadena );
printf( "He guardado: \"%s\" \n", cadena );
}
Ejecutamos el programa e introducimos la palabra "hola". Esto es lo que tenemos:
Escribe una palabra: hola
He guardado: "hola"
Si ahora introducimos "hola amigos" esto es lo que tenemos:
Escribe una palabra: hola amigos
He guardado: "hola"
Slo nos ha cogido la palabra "hola" y se ha olvidado de amigos. Por qu? pues
porque scanf toma una palabra como cadena. Usa los espacios para separar
variables.
Es importante siempre asegurarse de que no vamos a almacenar en cadena ms
letras de las que caben. Para ello debemos limitar el nmero de letras que le va a
introducir scanf. Si por ejemplo queremos un mximo de 5 caracteres usaremos
%5s:
#include <stdio.h>
#include <string.h>
int main()
{
char cadena[6];
printf( "Escribe una palabra: " );
fflush( stdout );
scanf( "%5s", cadena );
printf( "He guardado: \"%s\" \n", cadena );
}
Si metemos una palabra de 5 letras (no se cuenta '\0') o menos la recoge sin
problemas y la guarda en cadena.
Escribe una palabra: Gorka
He guardado: "Gorka"
Si metemos ms de 5 letras nos cortar la palabra y nos dejar slo 5.
Escribe una palabra: Juanjo
He guardado: "Juanj"

Scanf tiene ms posibilidades (consulta la ayuda de tu compilador), entre otras

permite controlar qu caracteres entramos. Supongamos que slo queremos coger
las letras maysculas:
#include <stdio.h>
#include <string.h>
int main()
{
char cadena[30];
printf( "Escribe una palabra: " );
fflush( stdout );
scanf( "%[A-Z]s", cadena );
printf( "He guardado: \"%s\" \n", cadena );
}
Guarda las letras maysculas en la variable hasta que encuentra una minscula:
Escribe una palabra: Hola
He guardado: "H"
Escribe una palabra: HOLA
He guardado: "HOLA"
Escribe una palabra: AMigOS
He guardado: "AM"

gets
Esta funcin nos permite introducir frases enteras, incluyendo espacios.
#include <stdio.h>
char *gets(char *buffer);
Almacena lo que vamos tecleando en la variable buffer hasta que pulsamos ENTER.
Si se ha almacenado algn caracter en buffer le aade un '\0' al final y devuelve un
puntero a su direccin. Si no se ha almacenado ninguno devuelve un puntero NULL.
#include <stdio.h>
#include <string.h>
int main()
{
char cadena[30];
char *p;
printf( "Escribe una palabra: " );
fflush( stdout );
p = gets( cadena );
if (p) printf( "He guardado: \"%s\" \n", cadena );
else printf( "No he guardado nada!\n" );
}
Esta funcin es un poco peligrosa porque no comprueba si nos hemos pasado del
espacio reservado (de 29 caracteres en este ejemplo: 29letras+'\0').

Qu son los buffer y cmo funcionan

#include <stdio.h>
int main()
{
char ch;
char nombre[20], apellido[20], telefono[10];
printf( "Escribe tu nombre: " );
scanf( "%[A-Z]s", nombre );
printf( "Lo que recogemos del scanf es: %s\n", nombre );
printf( "Lo que haba quedado en el buffer: " );
while( (ch=getchar())!='\n' )
printf( "%c", ch );
}
Escribe tu nombre: GORka
Lo que recogemos del scanf es: GOR
Lo que haba quedado en el buffer: ka
Cuidado con scanf!!!
#include <stdio.h>
int main()
{
char nombre[20], apellido[20], telefono[10];
printf( "Escribe tu nombre: " );
scanf( "%s", nombre );
printf( "Escribe tu apellido: " );
gets( apellido );
}

getchar
Recorrer cadenas con punteros
Las cadenas se pueden recorrer de igual forma que hacamos con las matrices,
usando punteros.
Vamos a ver un ejemplo: Este sencillo programa cuenta los espacios y las letras 'e'
que hay en una cadena.
#include <stdio.h>
#include <string.h>
int main()
{
char cadena[]="Gorka es un tipo estupendo";
char *p;
int espacios=0, letras_e=0;
p = cadena;
while (*p!='\0')
{
if (*p==' ') espacios++;
if (*p=='e') letras_e++;
p++;
}

printf( "En la cadena \"%s\" hay:\n", cadena );

printf( " %i espacios\n", espacios );
printf( " %i letras e\n", letras_e );
}
Para recorrer la cadena necesitamos un puntero p que sea de tipo char. Debemos
hacer que p apunte a la cadena (p=cadena). As p apunta a la direccin del primer
elemento de la cadena. El valor de *p sera por tanto 'G'. Comenzamos el bucle. La
condicin comprueba que no se ha llegado al final de la cadena (*p!='\0'),
recordemos que '\0' es quien marca el final de sta. Entonces comprobamos si en la
direccin a la que apunta p hay un espacio o una letra e. Si es as incrementamos
las variables correspondientes. Una vez comprobado esto pasamos a la siguiente
letra (p++).
Dos cosas muy importantes: primero no debemos olvidarnos nunca de inicializar un
puntero, en este caso hacer que apunte a cadena. Segundo no debemos olvidarnos
de incrementar el puntero dentro del bucle (p++), sino estaramos en un bucle
infinito siempre comprobando el primer elemento.
En la condicin del bucle podamos usar smplemente: while (!*p), que es
equivalente a (*p!='\0').
En este otro ejemplo sustitumos los espacios por guiones:
#include <stdio.h>
#include <string.h>
int main()
{
char cadena[]="Gorka es un tipo estupendo";
char *p;
p = cadena;
while (*p!='\0')
{
if (*p==' ') *p = '-';
p++;
}
printf( "La cadena queda: \"%s\" \n", cadena );
}
y se obtiene:
La cadena queda: "Gorka-es-un-tipo-estupendo"

Arrays de cadenas
Un array de cadenas puede servirnos para agrupar una serie de mensajes. Por
ejemplo todos los mensajes de error de un programa. Luego para acceder a cada
mensaje basta con usar su nmero.
#include <stdio.h>
#include <string.h>
int error( int errnum )
{
char *errores[] = {

"No
"No
"No
"Me
};

se ha producido ningn error",

hay suficiente memoria",
hay espacio en disco",
he cansado de trabajar"

printf( "Error nmero %i: %s.\n", errnum, errores[errnum] );

exit( -1 );
}
int main()
{
error( 2 );
}
El resultado ser:
Error nmero 2: No hay espacio en disco.
Un array de cadenas es en realidad un array de punteros a cadenas. El primer
elemento de la cadena ("No se ha producido ningn error") tiene un espacio
reservado en memoria y errores[0] apunta a ese espacio.

Ordenar un array de cadenas

Vamos a ver un sencillo ejemplo de ordenacin de cadenas. En el ejemplo tenemos
que ordenar una serie de dichos populares:
#include <stdio.h>
#include <string.h>
#define ELEMENTOS

int main()
{
char *dichos[ELEMENTOS] = {
"La avaricia rompe el saco",
"Ms Vale pjaro en mano que ciento volando",
"No por mucho madrugar amanece ms temprano",
"Ao de nieves, ao de bienes",
"A caballo regalado no le mires el diente"
};
char *temp;
int i, j;
printf( "Lista desordenada:\n" );
for( i=0; i<ELEMENTOS; i++ )
printf( " %s.\n", dichos[i] );
for( i=0; i<ELEMENTOS-1; i++ )
for( j=0; j<ELEMENTOS; j++ )
if (strcmp(dichos[i], dichos[j])>0)
{
temp = dichos[i];
dichos[i] = dichos[j];
dichos[j] = temp;
}
printf( "Lista ordenada:\n" );
for( i=0; i<ELEMENTOS; i++ )
printf( " %s.\n", dichos[i] );

}
Cmo funciona el programa:
1.- Tomamos el primer elemento de la matriz. Lo comparamos con todos los
siguientes. Si algunos es anterior los intercambiamos. Cuando acabe esta primera
vuelta tendremos "A caballo regalado no le mires el diente" en primera posicin.
2.- Tomamos el segundo elemento. Lo comparamos con el tercero y siguientes. Si
alguno es anterior los intercambiamos. Al final de esta vuelta quedar "A caballo
regalado no le mires el diente" en segunda posicin.
Para mayor claridad (eso espero) voy a sustituir cada cadena por su primera letra
(menos la de "Ao de nieves..." que la sustituyo por A). Y as represento el
proceso:
0
9
1
2
3
M
4
N
5
L

1
9'

L
M
N

2
10

L
M
N

3'

4'

6'

7'

8'

L
M
N

A
M
N

A
M
N

A
M
N

M
N

M
N

L
N

L
N

A
N

10'
L
M
N

L
A

A
N

A
N

A
M

M
A