Cadenas (Strings).

Los ˂arrays˃ son variables estructuradas, donde cada elemento se almacena de forma consecutiva en
memoria. Las cadenas o ˂strings˃ son declaradas en Dev C++ como ˂arreglos de caracteres˃ y permiten la
utilización de un cierto número de notaciones y de funciones especiales. Las cadenas o ˂strings˃ se
caracterizan porque permiten almacenar letras en lugar de números (como lo haríamos en una ˂array˃ o
arreglo convencional).

En C no existe un tipo predefinido para manipular cadenas de caracteres (string). Sin embargo, el estándar de
C define algunas funciones de biblioteca para tratamiento de cadenas. Una cadena en C es un array de
caracteres de una dimensión (vector de caracteres) que termina con el carácter especial ‘\0’ (cero).

Sintaxis: char nombre [longitud]; // Cadena variable

char nombre []=”cadena de caracteres fijos”; // Cadena fija

Dónde:
Char Representa el tipo de dato que podrá ser almacenado dentro de la cadena o string.
Nombre Nombre de la cadena o string que almacenará los datos de carácter ingresados.
Longitud Tamaño real de la cadena o string de caracteres +1

Instrucción scanf con cadenas (strings).

El uso de la instrucción ˂scanf˃ con cadenas (strings) nos permite almacenar en la variable definida la cadena
de caracteres de manera temporal, es decir, la instrucción ˂scanf˃ almacena en una porción temporal de
memoria (buffer) lo que vamos escribiendo; entonces cuando pulsamos ˂ENTER˃ lo analiza, comprueba si el
formato es correcto y, por último, lo almacena en la variable que le indicamos.

Ejemplo:
#include “stdio.h”
main ()
{
char cadena [30];
printf (“Escribe una palabra: ”);
scanf (“%s”, cadena);
printf (“\n Se ha almacenado en el buffer: \”%s\” \n”, cadena);
}

Si ahora ejecutamos el código anterior e introducimos "hola amigos" esto es lo que tenemos:
Escribe una palabra: hola amigos
Se ha almacenado en el buffer: “hola”

Sólo ha mostrado en pantalla "hola" y se ha olvidado de amigos. ¿Por qué? R= Porque ˂scanf˃ toma una palabra
como cadena y usa los espacios para separar variables. Entonces el espacio lo toma como un final de la cadena
de caracteres.

También puede llamar la atención sobre la forma de imprimir el ˂string o cadena˃ ya que con sólo usar ˂%s˃ ya
se imprime su totalidad.
Es importante siempre asegurarse de que no vamos a almacenar en cadena más caracteres que los que caben.
Para ello debemos limitar el número de los mismos que va a introducir scanf. Si, por ejemplo, queremos un
máximo de 5 caracteres, usaremos %5s:
Ejemplo:
#include “stdio.h”
main ()
{
char cadena [6];
printf (“Escribe una palabra: ”);
scanf (“%5s”, cadena);
printf (“\n Se ha almacenado en el buffer: \”%s\” \n”, cadena);
}

Si introducimos una palabra de 5 caracteres se almacenará sin problemas y será guardada en la cadena:
Escribe una palabra: Adios
Se ha almacenado en el buffer: “Adios”

Si ahora ejecutamos el código anterior e introducimos "Armando", que es una palabra de más de 5 caracteres
entonces esto se obtiene de la ejecución del código:
Escribe una palabra: Armando
Se ha almacenado en el buffer: “Arman”

Adicionalmente la instrucción ˂scanf˃ permite controlar qué caracteres pueden ser introducidos/asignados.
Supongamos que sólo queremos almacenar/asignar las letras mayúsculas de una palabra o frase ingresada.

Ejemplo:
#include “stdio.h”
main ()
{
char cadena [30];
printf (“Escribe una palabra: ”);
scanf (" %[A-Z]s ", cadena);
printf (“\n Se ha almacenado en el buffer: \”%s\” \n”, cadena);
}

Si introducimos una palabra que inicie con una letra mayúscula se almacenará sin problemas y será guarda en
la cadena hasta que encuentre una letra minúscula:
Escribe una palabra: Aloha
Se ha almacenado en el buffer: “A”

Si ahora ejecutamos el código anterior e introducimos "HOLA", entonces esto se obtiene de la ejecución del
código:
Escribe una palabra: HOLA
Se ha almacenado en el buffer: “HOLA”

Instrucción puts (put string).

La instrucción ˂puts˃ simplemente nos permite imprimir una cadena de caracteres básica en una impresión
estándar de un mensaje en pantalla además de aplicar un salto de línea de manera automática.

Sintaxis: puts (“string”);

Ejemplo:
#include “stdio.h”
main ()
{
puts (“Bienvenidos al Lenguaje de Programación Dev C++”);
puts (“Con este ejemplo de una cadena de caracteres”);
}

Instrucción gets (get string).

La instrucción ˂gets˃ simplemente toma una cadena de caracteres desde una entrada de datos estándar (cuya
introducción es preciso terminar con un ˂ENTER˃) y la almacena en una variable de tipo ˂string˃. Esta
instrucción nos permite introducir frases enteras de caracteres, incluyendo espacios.

Sintaxis:
Declarar el tipo de cadena y longitud:

char nombre string [longitud];

Mandar a llamar la cadena de caracteres para mostrar en pantalla:

gets (nombre string);

Dónde:
Nombre string Nombre asignado por el programador a la variable de tipo ˂string˃ que almacenará de
manera automática la cadena de caracteres ingresada por medio del teclado.
Longitud Longitud de la cadena de caracteres que será ingresada por medio del teclado.
Char Tipo de datos de carácter que permitirá almacenar la cadena de caracteres.

Ejemplo:
#include “stdio.h”
main ()
{
char cadena [50];
puts (“Escriba un texto cualquiera: ”);
gets (cadena);
puts (“La cadena de caracteres ingresados por medio del teclado es: ”);
puts (cadena);
}

La declaración ˂ char cadena[50]; ˃ crea una variable llamada cadena que puede almacenar hasta 50 caracteres.
Sin embargo el uso de esta cadena puede generar errores al rebasar el límite de caracteres ingresados y
almacenados en la variable generada ya que no se tiene una manera o método definido para comprobar si nos
hemos pasado del espacio reservado.
Funciones para manejo de cadenas.
Existen ciertas funciones dentro de la biblioteca estándar de Dev C++ para el manejo de cadenas, las cuales
funcionan siempre y cuando se incluya o añada el uso de la directiva ˂string.h˃ dentro del cuerpo del código
fuente, es decir: #include ˂string.h˃

La biblioteca “string” tiene una gran cantidad de funciones prácticas para trabajar con cadenas de caracteres.
Estas funciones nos permiten realizar ciertas acciones con 1 o más cadenas definidas, como son las siguientes:

 strlen → string length (longitud de la cadena)

 strcpy → string copy (copiar la cadena)
 strcat → string concatenate (concatenar / juntar 2 o más cadenas)
 sprintf → almacenar cadena en una variable (similar a concatenar 2 cadenas)
 strcmp → string compare (compara 2 cadenas hasta encontrar un carácter diferente)
 strcmpi → string compare (compara 2 cadenas sin importar mayúsculas o minúsculas)
 strupr → string upper case (convierte la cadena de caracteres a mayúsculas )
 strlwr → string lower case (convierte la cadena de caracteres a minúsculas)
 strrev → string reverse (invertir el orden de 2 cadenas)

Para utilizarlas debemos de incluir el fichero que define las características y sintaxis de dichas funciones.

strlen - Esta función devuelve el número de caracteres que tiene la cadena (sin contar el '\0').
Ejemplo: Para contabilizar los caracteres de una cadena ingresada.
#include <stdio.h>
#include <string.h>
main ()
{
int longitud;
char texto [20];
printf (“Escribe una palabra: ”);
scanf (“%s”, texto);
longitud= strlen (texto);
printf (“La cadena de caracteres \”%s\” tiene %i caracteres. \n”, texto, longitud);
}

strcpy - Copia el contenido de ˂cadena2˃ en la ˂cadena1˃. La ˂cadena2˃ puede ser una variable o una
cadena directa. Debemos tener cuidado de que la cadena destino ˂cadena1˃ tenga espacio suficiente para
albergar a la cadena origen ˂cadena2˃.

Ejemplo: Para copiar el contenido definido de una cadena 1 dentro de una cadena vacía 2.
#include <stdio.h>
#include <string.h>
main ()
{
char cadena_origen []= “Este es un ejemplo de una cadena escrita en este curso de Dev C++”;
char cadena_destino [50];
strcpy (cadena_destino, cadena_origen); // copia el contenido de la cadena origen en destino
printf (“\n\n La cadena final es: %s \n”, cadena_destino);
}
Ejemplo: En este ejemplo la cadena destino es una cadena constante y no una variable. Además, en este ejemplo
vemos que la cadena origen es sustituida por la cadena destino totalmente. Si la cadena origen es más larga que
la destino, se eliminan las letras adicionales.

#include <stdio.h>
#include <string.h>
main ()
{
char cadena_destino [50]= “Esto no es un curso de HTML ni Visual Basic, esto es Dev C++”;
printf( "%s\n", cadena_destino);
strcpy (cadena_destino, “Este es un curso básico de lenguaje de programación C++”);
printf (“\n\n %s \n”, cadena_destino);
}

strcat - Permite concatenar 2 cadenas, es decir , se unir o añadir el contenido de la ˂cadena2˃ al final de la
˂cadena1˃.

Ejemplo: Para concatenar 2 cadenas.

#include <stdio.h>
#include <string.h>
main ()
{
char nombre [] = “Armando”;
char apellidos [] = “Apaez Flores”;
strcat (nombre, apellidos); // se concatena el contenido de ambas cadenas
printf (“\n\n El nombre completo es %s \n”, nombre);
}

sprintf - 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 número de caracteres guardados en la variable
destino. Con ˂sprintf˃ podemos repetir el ejemplo de ˂strcat˃ de manera más sencilla:

Ejemplo: Para concatenar 2 cadenas empleando sprintf.

#include <stdio.h>
#include <string.h>
main ()
{
char nombre_completo [50];
char nombre [] = “Armando”;
char apellidos [] = “Apaez Flores”;
sprintf (nombre_completo, “%s %s”, nombre, apellidos); // se concatena el contenido de ambas cadenas
printf (“\n\n El nombre completo es %s \n”, nombre_completo);
}

strcmp - Compara el contenido de la ˂cadena1˃ con el contenido de la ˂cadena2˃, es decir, realiza una
comparación del contenido de la ambas cadenas y a partir del primer carácter de cada cadena inicia la
comparación y así sucesivamente se continua con los siguientes caracteres hasta que algún carácter difiera o se
alcance el final de ambas cadenas. Esta comparativa devuelve o genera como resultado cualquiera de los
siguientes valores:
  Devuelve un valor < 0 (negativo) → si la ˂cadena1˃ es menor que ˂cadena2˃
 Devuelve un valor = 0 (cero) → si la ˂cadena1˃ es igual que ˂cadena2˃
 Devuelva un valor ˃ 0 (positivo) → si la ˂cadena1˃es mayor que ˂cadena2˃

Ejemplo: Para comparar el contenido de 2 cadenas.

#include <stdio.h>
#include <string.h>
int comparar;
main ()
{
char frase1[] = “Armando”;
char frase2[] = “Alejandria”;
comparar=strcmp (frase1, frase2); // se compara el contenido de ambas cadenas
printf (“\n\n La comparación de las cadenas genera el valor siguiente: %i \n”, comparar);
}

strcmpi - Esta función opera exactamente igual que la función anterior ˂strcmp˃ comparando el contenido
de ambas cadenas pero ahora no hay distinción entre mayúsculas y minúsculas, es decir, compara 2 cadenas sin
diferenciar si el contenido escrito esté mayúsculas y minúsculas Esta comparativa devuelve o genera como
resultado cualquiera de los siguientes valores:

 Devuelve un valor < 0 (negativo) → si la ˂cadena1˃ es menor que ˂cadena2˃

 Devuelve un valor = 0 (cero) → si la ˂cadena1˃ es igual que ˂cadena2˃
 Devuelva un valor ˃ 0 (positivo) → si la ˂cadena1˃es mayor que ˂cadena2˃

Ejemplo: Para comparar el contenido de 2 cadenas sin importar si está escrito en mayúsculas o minúsculas.
#include <stdio.h>
#include <string.h>
int comparar;
main ()
{
char frase1[] = “ABEJA”;
char frase2[] = “abeja”;
comparar=strcmpi (frase1, frase2); // se compara el contenido de ambas cadenas
printf (“\n\n La comparación de las cadenas genera el valor siguiente: %i \n”, comparar);
}

strupr - Esta función convierte las letras minúsculas de una cadena en mayúsculas. La conversión es de letras
minúsculas (a - z) a las letras mayúsculas (A - Z). Otros caracteres no se modifican.

Ejemplo: Para convertir una cadena de caracteres de letras minúsculas a mayúsculas.

#include <stdio.h>
#include <string.h>
main ()
{
char frase[] = “abcdefghijklmnopqrstuvwxyz 0123456789 , . & / \ - _ * +”;
strupr (frase); // se conviertes las letras de la cadena en mayúsculas
printf (“\n\n La cadena final de caracteres es: %s \n”, frase);
}
strlwr - Esta función convierte las letras mayúsculas de una cadena en minúsculas. La conversión es de letras
mayúsculas (A - Z) a las letras minúsculas (a – z). Otros caracteres no se modifican.

Ejemplo: Para convertir una cadena de caracteres de letras mayúsculas a minúsculas.

#include <stdio.h>
#include <string.h>
main ()
{
char frase[] = “ABCDEFGHIJKLMNOPQRSTUVWXYZ 0123456789 , . & / \ - _ * +”;
strlwr (frase); // se conviertes las letras de la cadena en minúsculas
printf (“\n\n La cadena final de caracteres es: %s \n”, frase);
}

strrev - Esta función invierte el orden de la cadena a excepción del carácter nulo que la termina. (Por
ejemplo, podría cambiar de string\0 a gnirts\0).

Ejemplo: Para convertir una cadena de caracteres de letras mayúsculas a minúsculas.

#include <stdio.h>
#include <string.h>
main ()
{
char frase[] = “Ferrocarril”;
strrev (frase); // se invierte el orden de los caracteres de la frase
printf (“\n\n La cadena invertida de caracteres es: %s \n”, frase);
}

Instrucción putchar.
La instrucción ˂putchar˃ nos permite escribir un único carácter en la salida estándar, es decir, permite la
escritura en pantalla de un carácter único definido por el programador. Su uso es sencillo y generalmente se
combina con el uso de la instrucción ˂printf˃ para la escritura del mismo en la pantalla como parte del mensaje
definido.

Sintaxis: putchar (codigo de caracter);

putchar ('caracter');

Dónde:
Código carácter número del símbolo deseado en código ASCII.
Carácter carácter tecleado directamente por el programador que se desea mostrar en la pantalla

Ejemplo:
#include “stdio.h”
main ()
{
putchar ('H');
putchar ('O');
putchar ('L');
putchar ('A');
putchar (32); // muestra el espacio entre ambas palabras (32 es el código ASCII del carácter espacio ' ')
putchar ('M');
putchar ('U');
 putchar ('N');
putchar ('D');
putchar ('O');
putchar ('\n'); // imprime un salto de línea tras el texto.
}

Instrucción getchar.
La instrucción ˂getchar˃ devuelve el carácter o muestra el carácter en la pantalla en una entrada de datos
estándar. Esta instrucción se utiliza para obtener un carácter pero no devuelve un carácter, sino un entero. Esto
se hace empleando un entero que podemos representar tanto el conjunto de caracteres del teclado como el
carácter numérico del conjunto de caracteres del código ASCII. Estos caracteres se suelen representar como un
entero que va del 0 al 127 o del 128 al 256 (modo extendido).

Sintaxis: getchar ( );

Ejemplo:
#include “stdio.h”
main ()
{
int c;
c = getchar (); // Nótese que la instrucción getchar no devuelve ningún valor hasta presionar ENTER
putchar (c);
}
Aquí se almacena el carácter ingresado por medio del teclado en la variable entera ˂c˃, posteriormente se
muestra impreso en pantalla haciendo uso de la instrucción ˂putchar˃.

Instrucción scanf para múltiples entradas.

La instrucción ˂scanf˃ puede emplearse para permite la entrada/lectura múltiple de valores que serán
asignados a diferentes variables declaradas respectivamente, es decir, podemos preguntar por más de una
variable a la vez en un solo scanf, de modo que es preciso poner un ˂ %tipo dato ˃ por cada variable definida.

Sintaxis:
scanf (“%tipo dato1 %tipodato2 %tipodato3”, &variable1, &variable2, &variable3);

Dónde:
%tipo dato X Corresponde al tipo de datos que podrá ser almacenado en la variable definida por el
programador:
%f para datos flotantes
%i o %d para datos enteros
% c o %s para datos de tipo carácter
Variable X Nombre de la variable a la que le será asignado el valor leído/introducido por medio del
teclado como una entrada de información.
Ejemplo:
#include “stdio.h”
main ()
{
int a, b, c;
printf (“Introduce el valor para tus tres variables: ”);
scanf (“%i %i %i”, &a, &b, &c);
printf (“\n Has tecleado los siguientes valores %i %i %i \n”, a, b, c);
}
De esta forma, cuando el usuario ejecuta el programa debe introducir los tres datos separados por un espacio.

También podemos utilizar la instrucción ˂scanf˃ para introducir/asignar valores de diferente tipo a diferentes
variables.
Ejemplo:
#include “stdio.h”
main ()
{
int a;
float b;
printf (“Introduce el valor para tus dos variables: ”);
scanf (“%i %f ”, &a, &b);
printf (“\n Has tecleado los siguientes valores %i %f \n”, a, b);
}

A cada modificador ”%i y %f” le debe corresponder una variable de su mismo tipo. Es decir, al colocar ˂%i˃ el
compilador espera que su variable correspondiente sea de tipo ˂int˃. Si ponemos ˂%f˃ se espera una variable
tipo ˂float˃.

Sin embargo cuando empleamos este tipo de asignación de datos (combinando tipos de datos) es requerido de
presionar ˂ENTER˃ por cada variable ingresada para que sea almacenada en la variable correspondiente.

Instrucción cin.getline ().

Siguiendo con la línea de las instrucciones de la librería ˂string.h˃ se puede emplear ésta función que es muy
útil al trabajar con ˂cadenas o strings˃. Como ya sabemos un/una ˂string o cadena˃ es una variable que puede
contener cero, uno o más caracteres almacenadas dentro de ella.

Ahora veremos cómo introducir una cadena o string (que el usuario la introduzca por medio del teclado).

Sintaxis: cin.getline (nombre, longitud, character de fin);

Dónde:
Nombre Es el nombre de la variable que va a contener o almacenar el string o cadena.
Longitud La cantidad de caracteres que queremos que se puedan introducir (nunca mayor que
la longitud del string).
Caracter de fin El carácter que el usuario va usar como final de la cadena. Por lo general es el ˂ENTER˃
que se representa como: ‘\n’
Por ejemplo, supongamos que tenemos un arreglo char de 500 elementos llamado cadena (nuestra string) y
queremos pedirle al usuario que la “llene”, entonces la función ˂cin.getline˃ quedaría así:

cin.getline(cadena, 500, '\n');

Como ven, los parámetros van separados por comas (,), y el carácter de fin está entre comillas simples (‘).

Instrucción fflush.
Para mejorar las prestaciones del manejo de ficheros se utilizan buffers, almacenes temporales de datos en
memoria, las operaciones de salida se hacen a través del buffer, y sólo cuando el buffer se llena se realiza la
escritura en el disco y se vacía el buffer. En ocasiones nos hace falta vaciar ese buffer de un modo manual, para
eso sirve ésta función.

Sintaxis: fflush (stdin);

El propósito de utilizar esta instrucción o función es forzar la grabación de los datos acumulados en el buffer de
salida o bien eliminar el contenido del buffer de memoria que almacena temporalmente los datos que se van
almacenando en ella antes de presionar la tecla de ˂ENTER˃.

Esta se emplea o utiliza mucho cuando se manejan cadenas o strings, arreglos o arrays y manejo de archivos
externos.

Ejemplo:
#include <iostream>
#include <stdio.h>
#include <string.h>
using namespace std;
main ()
{
char frase[200];
printf("Ingresa la cadena (en MAYUSCULAS) para convertirla a minusculas: ");
cin.getline (frase, 200, '\n');
fflush(stdin);
strlwr(frase);
printf("\n\nEsta es la cadena en minusculas: %s \n ",frase);
}