Lenguaje C

Cadena de caracteres
Atento: Se escribe caracter, sin acento; as suena en informtica.

Caracteres
Un caracter es una letra minscula, mayscula; un nmero: 0,1, 2, 3, 4, 5, 6, 7, 8, 9; signos de puntuacin: , !, , ?, .. otros caracteres
como, <, >, %, $ _, @, etc; otros que son invisibles a las personas y sirven para representar eventos propios de la interaccin con la
computadora, ejemplo: presionar la tecla <enter>.

El computador guarda en cada posicin de memoria solo 2 estados 0 y 1 (bit); un grupo de bits puede ser interpretado como nmero,
en bases 2, 4, 8, 16 (las ms usadas), ; es ms elaborado interpretarlos en base 10. 1 byte = 8 bits pude ser interpretado como
caracter, de acuerdo a la tabla ascii:
Tabla ascii (Un carcter se guarda en un byte = 8 bits)
Nmero Caracter
0 Espacio en blanco, carcter nulo

97 a
98 b
99 c
..
255
Esta tabla tiene 256 nmeros que son interpretados como 256 caracteres
En un programa, los caracteres se escriben dentro de comillas simples, ejemplos: 'a', '1', '&', '+', ' ' (carcter blanco), etc. Los caracteres
invisibles se escriben en modo especial, por ejemplo para indicar <enter>:
En un programa se escribe: '\n'
En la comunicacin humana, por ejemplo en este libro, utilizamos LF (Line Feed, en ingls)
En el monitor y el teclado, aparecen sin comillas, ejemplos: a, 1, &, +, (espacio en blanco), etc; los caracteres invisibles, Obvio: no se
ven en el monitor.

Definicin y uso
char dato; // Tipo char
scanf(%c, &dato); // tipee b
printf(\Dato: %c, dato);
Salida: b

Intercambio de caracteres y nmeros:

En el captulo 1 vimos que char hace casting automtico a int, por lo tanto, se cumple:
char dato;
scanf("%c", &dato); // lee con formato caracter
printf("Caracter = %c, Nmero = %d\n", dato, dato); // escribe con formato carcter y numrico.
Salida: Caracter = a, Nmero = 97 // 97 es el cdigo ascci de 'a'.

char dato;
scanf("%d", &dato); // tipee 97 Lee con formato carcter, al compilar se produce un warning, pero compila
printf("Caracter = %c, Nmero = %d\n", dato, dato);
Salida: Caracter = a, Nmero = 97 // 97 es el cdigo ascci de 'a'.

Antes usamos un dato de tipo char; ahora haremos las mismas operaciones, pero el dato ser de tipo int:
int dato;
scanf("%d", &dato); // tipee 97 // lee con formato caracter
printf("Caracter = %c, Nmero = %d\n", dato, dato); // escribe con formato carcter y numrico.
Salida: Caracter = a, Nmero = 97 // 97 es el cdigo ascci de 'a'.

int dato;
scanf("%c", &dato); // tipee a Lee con formato carcter, al compilar se produce un warning, pero compila
printf("Caracter = %c, Nmero = %d\n", dato, dato);
Salida: Caracter = a, Nmero = 97 // 97 es el cdigo ascci de 'a'.

En el captulo de Funciones aprendimos acerca de la sintaxis de funciones, lo cual es necesario para entender la enorme cantidad de
funciones de las libreras de C; en particular las que se aplican a caracteres y cadenas de caracteres.

PGINA: 1
 Lenguaje C
Aritmtica limitada de caracteres
Suma o resta de nmeros a caracteres: 'a' + 1 = 'b'; ejemplo:
char dato = 'a';
printf("\n Nmero) = %d; Caracter = %c ", dato, dato); // Resultado: Nmero = 97; Caracter = a
printf("\n Nmero) = %d; Caracter = %c ", dato + 1, dato + 1);
Salida:
Nmero = 97; Caracter = a
Nmero = 98; Caracter = b

Restar dos caracteres: 'b' - 'a' = 1

Comparar dos caracteres, ejemplo:

Programa 07_01.c:
#include<stdio.h>
void main(void){
char dato1 = a, dato2 =b;
if(dato1 > dato2) printf(\n %c es mayor que %c, dato1, dato2);
else if(dato1 == dato2) printf(\n %c es igual a %c, dato1, dato2);
else printf(\n %c es menor que %c, dato1, dato2); // salida
}
Salida:
a es menor que b

Entrada de datos desde el teclado (stdin)

La lectura de datos desde el teclado requiere especial cuidado debido al uso de una memoria intermedia pequea y temporal llamada
buffer:
teclado buffer lectura.
En forma figurada el buffer es parecido al tanque de agua de una casa: el agua llega al tanque y se deposita y luego la consumimos;
cuando el tanque est vacio, esperamos a que se llene; cuando est lleno, debemos cuidar de no consumir ms de la cuenta, porque
faltar.

En el computador sucede lo siguiente: Al procesar una instruccin de lectura, por ejemplo:

scanf(%c, &cc);
El computador trata de leer del buffer; si no est vaco, lee; si est vaco, espera a que usted tipee una lnea<enter> toda la lnea se
copia en el buffer, incluyendo el <enter> y se leera datos del buffer. Cuando lea caracteres, lo ideal es:
le solicitan datos
lee con scan(), u otro.
vaca el buffer, por ejemplo: while(getchar() != 10); y queda listo para la siguiente lectura,

Funciones de entrada de caracteres desde teclado

Descripcin
Leer un carcter
Leer del teclado una lista
de variables, los caracteres
tienen formato %c
Sintaxis Ejemplos
int getchar(void); int cc;
salida: cdigo ascii leido, esto le permite leer caracteres cc = getchar(); // tipee <enter>
importantes, como: <enter> printf("%d\n", cc); // Salida: 10
int scanf(const char *format, ...); Char c1, c2;
Entrada: scanf(%c %c, &c1, &c2);
const char *format (puntero constante a char): formato Lee valores de tipo caracter para c1
: lista de posiciones de variables y c2, segn el formato %c %c
Salida: 0 si no ley ningn valor; Tipee: a b
n = nmero de valores leidos. c1 a, c2 b
scan lee datos de diferentes tipos

Atento, en el ejemplo de la funcin getchar(), se utiliz:

int cc; // no: char cc;
Esto se hace con frecuencia, porque int da ms opciones que char. Recuerde que los datos int, hacen casting a char automticamente;
El siguiente cdigo es similar al ejemplo dado en la funcin getchar()
int cc;
cc = getchar(); // tipee a
printf("%c\n", cc); // Escribir un nmro con formato %c
Salida: a

PGINA: 2
 Lenguaje C
Ejemplo: leer varios caracteres
Programa: 07_02.c:
#include<stdio.h>
void main(void){
char cc, dd, ee;
cc = getchar(); // Tipee ab<enter> se guarda en el buffer, y lee 'a'
dd = getchar(); // lee 'b' del buffer
ee = getchar(); // lee <enter> del buffer
printf("\ncc = %c", cc);
printf("\ndd = %c", dd);
printf("\nee = %d\n", ee); // se usa formato %d, porque el caracter <enter> es invisible
}
Salida:
cc = a
dd = b
ee = 10 // <enter>
Este programa funciona bien, pero no es lo ms conveniente; veamos un ejemplo ilustrativo:
pregunte:
Te gusta cantar (s/n): // responda s o n
Te gusta bailar (s/n) : // responda s o n
Responda:
Chvere, llvame contigo // si respondi s s
Bueno, te enseare a bailar // si respondi s n
Bueno, te enseare a cantar // si respondi n s
Fuera de ac aburrido // si respondi n n
Programa: 07_03.c:
#include<stdio.h>
void main(void){
char cantar, bailar;
printf("Te gusta cantar (s/n): ");
cantar = getchar();
printf("Te gusta bailar (s/n): ");
while(getchar() != 10); // vaca el buffer
bailar = getchar();
if (cantar=='s')
if (bailar=='s') printf("Chvere, llvame contigo\n");
else printf("Bueno, te enseare a bailar\n");
else if (bailar=='s') printf("Bueno, te enseare a cantar\n");
else printf("Fuera de ac aburrido\n");
}
Salida:
Te gusta cantar (s/n): s
Te gusta bailar (s/n): s
Chvere, llvame contigo
El programa funcion bien, por que vaci el buffer, si no lo hace tendr problemas

Funciones de salida de caracteres al monitor (stdout):

Descripcin Sintaxis Ejemplo
Imprime un carcter int putchar(int char); char cc = 'a';
(sin formato) Salida: 1 exitoso, 0 error putchar(cc);
// salida: a.
Escribe informacin de int printf(const char *format, ...); char cc = 'a';
acuerdo a un formato Salida: el nmero de caracteres escritos printf(cc = %c, cc);
// salida: cc = a
Ejemplo:
printf("%d\n", printf("El nmero de caracteres en este mensaje es: "));
Salida: El nmero de caracteres en este mensaje es: 45

Explicacin:
El printf() interno:
printf("El nmero de caracteres en este mensaje es: ")
Escribe: El nmero de caracteres en este mensaje es: // y da como salida 45
PGINA: 3
 Lenguaje C

El printf() externo:
printf("%d\n", 45)
Completa la escritura: El nmero de caracteres en este mensaje es: 45.

Ejercicio: Escriba, compile y ejecute un programa que lea una letra minscula (valide que sea as) y la convierta en mayscula.

Arreglo y Cadena de caracteres

Un arreglo de caracteres se define con el tio char, por ejemplo:
char ar2[2][2];
char ar1[3] = {'a', 'b', 'c'};
.
Se define, asigna valores, manipula y funciona, como a cualquier otro arreglo.

Una cadena de caracteres es un arreglo de caracteres de una dimensin, que contiene al menos una vez el carcter: '\0' (NULL, cdigo
ascii = 0), ejemplo:
char arr[5] = {'a', 'b', '\0','c', '\0' };
arr
a b \0 c \0
Posiciones 0 1 2 3 4

La cadena Inicia en la posicin 0, en este ejemplo, con el carcter 'a'. Termina cuando encuentra el primer '\0', en este ejemplo, en la
posicin 2.
La cadena esta compuesta por: 'a', 'b' y '\0'. Despus de esta posicin, no se consideran los elementos, en este caso se desperdician:
'c' y '\0'.
El primer carcter '\0' indica el fin de la cadena. La longitud de la cadena se calcula con strlen(arr), ejemplo:
Programa: 07_04.c: // para utilizar funciones de arreglos, incluya la librera string.h
#include<stdio.h>
#include<string.h> // librera para funciones de cadena
void main(void){
int i;
char arr[5] = {'a', 'b', '\0','c', '\0' };
printf("Arreglo : ");
for(i=0; i<5; i++) printf("%c", arr[i]);
printf("\nLongitud de arreglo: %lu\n elementos", sizeof(arr));
printf("Cadena : %s", arr);
printf("\nLongitud de cadena: %lu\n caracteres", strlen(arr));
}
Salida:
Arreglo : abc
Longitud de arreglo: 5 elementos
Cadena : ab
Longitud de cadena: 2 caracteres
Note que arr cumple el rol de arreglo y de cadena; adems strlen(arr) < sizeof(arr)

Es responsabilidad del programador no exceder los lmites de arreglos y cadenas; el compilador no reporta error si se exceden; pero
en tiempo de ejecucin se producen resultados inesperados o errores de memoria (violacin de segmento); por ejemplo:
Printf(\n arr[0] = %c arr[1] = %c, arr[0], arr[1]); // Salida: arr[0] = a, arr[1] = b
arr[0] = x; // Asigna x al primer elemento
arr[-1] = r; // compila, pero hay problemas en tiempo de ejecucin
arr[2] = z; // compila, pero la cadena se agranda, ahora es: xbzc
arr[4] = d; // compila, pero ya no es cadena sino arreglo que contiene: xbzcd.
arr[7] = z; // compila, pero hay problemas en tiempo de ejecucin

Asignacin de valores a una cadena:

Veamos varios modos de asignar valores:
char arr[5] = {1, 2, \0}; // El arreglo arr tiene 5 elementos, los dos ltimos se desperdician. La cadena arr tiene 2 caracteres
char arr[ ] = 12; // El compilador agrega '\0'. El arreglo arr tiene 3 elementos. La cadena arr tiene 2 caracteres.
char arr[ 3]; arr[0]= '1'; arr[1]= '2'; arr[3]= '\0';

PGINA: 4
 Lenguaje C
Funciones de entrada de cadenas caracteres desde teclado
Descripcin Sintaxis Ejemplos
Leer del teclado int scanf(const char *format, ...); char arr[3];
una lista de Entrada: scanf("%s", arr);
variables, las const char *format (puntero constante a char): formato // si tipea 123<enter>
cadenas tienen : lista de posiciones de variables arr contendr 123\0 (se desvorda), no ser
formato %s Salida: 0 si no ley ningn valor; una cadena, se corrompe la memoria (con
n = nmero de valores leidos. '\0'), y se vaca el buffer.
Lee del buffer hasta encontrar un espacio en blanco o <enter>, // si tipea 1 2<enter>
agrega '\0' al final de la cadena; no controla la longitud de la arr contendr 1\0, buffer contiene 2\0 y
cadena, y puede sobre pasar su longitud asignada. Por otra espera por la siguiente lectura.
parte si no se vaca el buffer, espera para ser ledo por la // scanf funciona perfecto cuando tipea una
siguiente lectura, cadena sin blancos (de longitud <= longitud
posible)<enter>, ejemplo:
si tipea: 1<enter>, o 12<enter>
Lectura de cadena. char *gets(char *buffer); char arr[6], *p;
Esta funcin, ser Parecida a scanf(), la diferencia es lo subrayado. *p = gets(arr); // lee caracteres para arr.
discontinuada, el Lee del buffer hasta encontrar <enter> y agrega \0 al final de la Salida:
compilador da un cadena if (*p == '\0') printf(No ley datos);
warning else printf(%s\n, arr);
(advertencia) Salida: puntero a buffer
Lectura de cadena Int leerString(char cc[ ], int n); char arr[6];
con longitud Parecida a las dos anteriores, la diferencia es lo subrayado. leerString(arr, 6);
controlada. Lee del buffer hasta encontrar <enter> se completen n-1 Si tipea: a b<enter> Salida: a b.
Fue necesario caracteres, agrega \0 al final de la cadena y desecha la cola de Ley 3 caracterees
programar la la cadena Si tipea: abcde<enter> Salida: abcde.
funcin leerString() Salida: nmero da caracteres leidos Ley 5 caracterees
Si tipea: abcdefg<enter>
Salida: abcde. Ley 5 caracterees
// #include <string.h>
int leerString(char cc[ ], int n){
int len;
fgets(cc, n, stdin);
len = (int)strlen(cc);
if (len<n-1) {cc[len-1] = '\0'; len--;}
if (len==n-1 && cc[n-2] == 10) {cc[n-2] = '\0'; len--;}
if (len>=n-1) do; while(getchar()!=10);
return len;
}

Funciones de salida de cadena de caracteres al monitor (stdout):

Descripcin
Escribe una cadena con
formato s
Escribe una cadena sin
formato
Escribe una cadena s en
un archivo de destino
Sintaxis Ejemplo
int printf(const char *format, ...); char arr[6] = abc;
Salida: El nmero de caracteres impesos + 1 printf(arr = %s, arr);
Salida: abc
int puts(const char *cadena); char arr[6] = abc;
Salida: El nmero de caracteres impesos + 1 puts(arr);
puts(Todo se entendi bien);
int fputs(const char *s, FILE *file) char arr[4] = abc;
s: cadena a imprimir fputs(arr, stdout);
file: destino de salida de datos
Salida: nmero de caracteres impesos + 1

Ejemplos
#include<stdio.h>
void main(void){
char datos[6];
printf("Ingrese una cadena de caracteres: ");
scanf("%s", datos); // Ingrese en el teclado: abc
printf("\nUsted ingreso: %s", datos); // Resultado: Usted ingreso: abc
}

PGINA: 5
 Lenguaje C
Nota:
Si en lugar de ingresar abc hubiera ingresado a bc
El resultado sera: Usted ingreso: a // esto se debe a que scanf("%s", datos); lee hasta el primer blanco
Para resolver este problema:
sustituya: scanf("%s", datos); por: leerString(datos, 6); // Ingrese en el teclado: a bc
Copie la funcin leerString(datos, 6) definida en la tabla anterior.
Problema resuelto.

Apuntadores a cadena de caracteres

char cc[ ] = abc, *pc = cc;
pc cc
a b c \0

Tambin puede manejar cadenas con punteros con gran facilidad:

Programa: 07_05.c
#include<stdio.h>
#include<string.h>
void main(void){
char *pc = "abc"; // define una cadena
puts(pc); // imprime una cadena
printf("Longitud: %lu\n", strlen(pc)); // imprime la longitud de la cadena
printf("Primer caracter: %c\n", pc[0]); // imprime un carcter de la cadena
printf("----------------\n");
pc = "123456"; // repite el trabajo con otra cadena. Muy fcil
puts(pc);
printf("Longitud: %lu\n", strlen(pc));
printf("Primer caracter: %c\n", pc[0]);
}
Salida:
abc
Longitud: 3
Primer caracter: a
----------------
123456
Longitud: 6
Primer caracter: 1

Las notaciones de arreglos y apuntadores son equivalentes para elementos de la cadena y para funciones:
Arreglo Apuntador
#include<stdio.h> #include<stdio.h>
#include<string.h> #include<string.h>
void main(void){ void main(void){
char cc[] = "abc"; char *pc = abc;
printf("%s\n", cc); printf("%s\n", pc);
} }
Salida: Salida:
abc abc
cc[1] = = *(cc+1) = 'b' pc[1] = = *(pc+1) = 'b'
strlen(cc) = 3 strlen(pc) = 3
scanf("%s", cc); scanf("%s", pc);
pc es constante, apunta a abc,
no puede apuntar a otro valor
printf("%s\n", cc); printf("%s\n", pc);
Apuntador a arreglo
#include<stdio.h>
#include<string.h>
void main(void){
char cc[] = "abc", *pc = cc;
printf("%s\n", cc);
printf("%s\n", pc);
}
Salida:
abc
abc
cc[1] = = *(cc+1) = = pc[1] = = *(pc+1) = 'b'
strlen(cc) = = strlen(pc) = 3
scanf("%s", cc); // = = scanf("%s", pc);
printf("%s\n", cc); // = = printf("%s\n", pc);

PGINA: 6
 Lenguaje C
Ejemplo: ElPoema 15 de Neruda inicia as:
Me gusta cuando callas porque ests como ausente
y me oyes desde lejos, Y mi voz no te toca
Parece que los ojos se te hubieran volado
y parece que un beso te cerrara la boca

Es una lista de cadenas de caracteres y la podemos guardarla de dos modos:

Programa: 07_06.c
#include <stdio.h>
void main(void){
int i=4;
// forma 1: Matriz de caracteres
char poema15[4][60] = {"Me gusta cuando callas porque ests como ausente",
"y me oyes desde lejos, Y mi voz no te toca",
"Parece que los ojos se te hubieran volado",
"y parece que un beso te cerrara la boca"};
for(i=0; i<4; i++) printf("%s\n", poema15[i]);
// forma 2: Arreglo de apuntadores a cadena de caracteres
char *ppoema15[4] = {"Me gusta cuando callas porque ests como ausente", // no indica longitud de cadena
"y me oyes desde lejos, Y mi voz no te toca",
"Parece que los ojos se te hubieran volado",
"y parece que un beso te cerrara la boca"};
for(i=0; i<4; i++) printf("%s\n",ppoema15[i]);
}
Salida:
Me gusta cuando callas porque ests como ausente
y me oyes desde lejos, Y mi voz no te toca
Parece que los ojos se te hubieran volado
y parece que un beso te cerrara la boca
2 veces

Parmetros y salida de la funcin main()

Los parmetros de main() se mamejan como una lista de apuntadores a cadenas de caracteres.
Recuerde que cuando se llama a una funcin se pasan argumentos y la funcin recibe parmetros (que se corresponden con los
argumentos). Hasta ahora hemos utilizado la funcin main() sin parmetros de entrada ni salida:
void main(void){....}
No recibimos nada ni retornamos nada.

Podemos omitir uno, o los dos, void:

main(){....}
No es recomendable, ya que seremos imprecisos en la especificacin de la entrada/salida.

Como entrada, tenemos el siguiente estndar:

main(int argc, char *argv[ ])
donde:
argc significa: argument counter (contador de argumentos) = nmero de elementos del arrreglo *argv.
argv significa: argument values (valores de los argumentos); es un arreglo de apuntadores a caracteres.

Programa: 07_07.c: Manejo de argumentos

// Imprime los parmetros de main()
#include <stdio.h>
int main(int argc, char *argv[]){
int i;
printf("argc : %d\n", argc); // nmero de argumentos
for(i=0; i<argc; i++) printf("argv[%d]: %s\n", i, argv[i]); // impresin de argumentos
return 1; // retorno de tipo entero.
printf("Nmero: %d\n", atoi(argv[3])); // atoi() convierte una cadena a nmero: atoi(31) 31
}

PGINA: 7
 Lenguaje C
Ejecucin: ./07_07 1 dos 3
Salida:
argc : 4 // 4 = Nmero de elementos de argv
argv[0] : ./07_07 // comando ordenado
argv[1] : 1 // primer argumento (como cadena de caracteres, un solo caracter)
argv[2] : dos // segundo argumento (como cadena de caracteres)
argv[3] : 3 // Tercer argumento (como cadena de caracteres, un solo caracter)
Nmero: 3 // Convierte el carcter '3' al nmero 3.

Funciones para cadenas

Notas:
1) Usaremos un nuevo tipo de dato: size_t, parecido a long unsigned, su formato de lectura/escritura es lu, ejemplo:
size_t n = 4;
printf("\nn = %lu\n",n);
Salida: n = 4
2) Si el compilador no encuentra las funciones, pruebe incluir las libreras:
#include<string.h>
#include<ctype.h>
3) Para manipular funciones se utilizan apuntadores, con mucha frecuencia.

Descripcin Sintaxis Ejemplo

Longitud de cadena arr
Comparar el orden de dos
cadenas arr1 y arr2
Apuntar a la posicin de un
carcter c en una cadena
cad
Copiar la cadena origen
sobre destino
Copiar n caracteres de
origen sobre destino
Concatenar arr1 con arr2
size_t strlen(char *arr); char arr[ ] = abc;
strlen(arr); // Salida: 3
int strcmp(const char *arr1, const char *arr2); char arr1[ ] = jklm, arr2[ ] = k1k;
Valores de retorno: strcmp(arr1, arr2); // Salida: -1
< 0 Si arr1 es menor que arr2
0 Si arr1 es igual a arr2
> 0 Si arr1 es mayor que arr2
char *strchr(const char *cad, int c); char cad[10] = "Hola amigo", c = 'a', *p;
p = strchr(cad, c);
printf("%lu", p-cad+1); // posicin de c = 4
char *strcpy(char *destino, const char *origen); char origen[ ] = a1a, destino[ ] = b b b;
strcpy(destino, origen);
// Salida: destino = a1a
char *strncpy(char *destino, const char *origen, size_t char origen[ ] = a1a, destino[ ] = b b b;
n); strncpy(destino, origen, 2);
// Salida: destino = a1b b
char *strcat(char *arr1, const char *arr2); char arr1[ ] = jklm, arr2[ ] = k1k;
strcat(arr1, arr2);
// Salida: jklmk1k
char *strncat(char *arr1, const char *arr2, size_t n); char arr1[ ] = jklm, arr2[ ] = k1k;
strncat(arr1, arr2, 2);
// Salida: jklmk1

Ejemplo: Leer varias lneas de texto con nombre y apellido (en una sola variable), colocarlas en las filas de una matriz e imprimirla.
Programa 07_08.c:
#include<stdio.h>
#include<string.h>
#define MAX 10
#define LONGE 60
void main(void){
char lista [MAX][LONGE], *fin; // En cada fila va una cadena
int n=0, i;
puts("Pulsa Enter para finalizar...");
do {
printf ("Nombre y apellidos: ");
fin = gets(lista[n]); // Lee una fila
if(*fin == '\0') break;
n++;
} while (n<MAX);
printf ("-----------------------------\n");
for (i=0;i<n;i++) printf ("\n Nombre y Apellidos: %s",lista[i]);
printf ("\n");

PGINA: 8
 Lenguaje C
}
salida:
Pulsa Enter para finalizar...
Nombre y apellidos: Carlos
Nombre y apellidos: Jose
Nombre y apellidos:
---------------------------------
Nombre y Apellidos: Carlos
Nombre y Apellidos: Jose

Ejemplo: Ampliar el ejercicio anterior. Leer varias lneas de texto con nombre y apellido (en una sola variable), colocarlas en las filas de
una matriz, ordenar e imprimir la matriz.
Podemos utilizar cualquier algoritmo de ordenamiento conocido, pero se presentar una problema de eficiencia en el tiempo, por que las
cadenas pueden ser muy largas y al intercambiarlas se pierde mucho tiempo. Si asociamos un arreglo de punteros al arreglo de cade -
nas, el programa ser un poco ms complejo y utilizaremos un poquito ms de espacio de memoria; pero ser mucho ms rpido.
Sugerencia: Copiar el programa anterior, agregar el arreglo de punteros, ordenar los punteros segn el orden de las cadenas e imprimir
las cadenas segn el orden de punteros.
Programa 07_09.c:
#include<stdio.h>
#include<string.h>
#define MAX 10
#define LONGE 60
void main(void){
char lista [MAX][LONGE], *plista[MAX], *pfin, *ptem;
int n=0, i, j;
puts("Pulsa Enter para finalizar...");
do { // Leer la lista
printf ("Nombre y apellidos: ");
pfin = gets(lista[n]);
if(*pfin == '\0') break;
plista[n] = lista[n];
n++;
} while (n<MAX);
for(i=0; i<n-1; i++) // ordenar punteros
for(j=i+1; j< n; j++)
if(strcmp(lista[i],lista[j]) > 0){
ptem = plista[i];
plista[i] = plista[j];
plista[j] = ptem;
}
for (i=0;i<n;i++) printf ("\n Nombre y Apellidos: %s",plista[i]);
printf ("\n");
}
salida:
Pulsa Enter para finalizar...
Nombre y apellidos: Jose
Nombre y apellidos: Carlos
Nombre y apellidos:

Nombre y Apellidos: Carlos

Nombre y Apellidos: Jose

Caracteres de uso frecuente

Nombre Descripcin Valor ascii Caracter Uso frecuente
NULL Fin de cadena de carcter 0 '\0' Al leer caracteres
LF Line feed (cambio de lnea) 10 '\n' Al leer caracteres
EOF End Of File (fin de archivo) o de stream -1 (No ascii, puede ser distinto) No tiene Al leer archivos

PGINA: 9
 Lenguaje C
Librera para caracteres
La librer ctype.h es un archivo de cabecera de la biblioteca estndar, contiene macros (una forma de programar funciones) y funciones
para clasificar caracteres:
Macro Descripcin: Valida caracteres
isalnum (A - Z o a z ) (0 - 9)
isalpha (A - Z o a - z)
isascii 0 - 127 (0x00-0x7F)
iscntrl (0x7F o 0x00-0x1F)
isdigit (0 - 9)
isgraph Imprimibles menos ' '
islower (a - z)
isprint Imprimibles incluido ' '
ispunct Signos de puntuacin
isspace espacio, tab, retorno de lnea, cambio de lnea, tab vertical, salto de pgina (0x09 a 0x0D, 0x20).
isupper (A-Z)
isxdigit (0 - 9, A - F, a f).
Ejemplo; isalpha('c'), retorna nmero distinto de 0 (verdad).

Funcin Descripcin
tolower Convierte carcter a minscula
toupper Convierte carcter a mayscula
atoi Convierte cadena de caracteres a int
Convierte cadena de caracteres a float, ejemplo:
#include <stdio.h>
#include <stdlib.h>
Atof void main(void){
printf("%f\n",atof("1.2"));
}
Salida: 1.2000
Ejemplo; tolower('C'), retorna c.

Ejercicios: Resuelva los ejercicios e imprima los resultados:

1) Lea del stdio la cadena hola mundo en dos modos

2) Lea del stdio la cadena hola mundo y convirtala a maysculas; HOLA MUNDO

3) Lea del stdio dos cadenas: saludo y nombre (por ejemplo: Hola y Juan) y forme una sola: HOLA Juan

4) Una cadena es palndroma si las letras de izquierda a derecha y al revs son las mismas, Ejemplo: ana es palndroma. Lea una
cadena y averigue si es, o no, palndroma.

5) Lea una cadena, por ejemplo; Hola mundo ordene los caracteres ascendentemente para que quede: Hadlmnoou
Sugerencia: vea un ejercicio similar para datos numricos.

6) Dadas 3 cadenas: cad1, cad2 y cad3 de caracteres, imprmalas en orden ascendente.

7) Leer varias lneas de texto con nombre y apellido (en una sola variable), colocarlas en las filas de una matriz, ordenar e imprimir la
matriz.
Sugerencia: Modifique el ltimo programa de la parte terica y utilice la siguiente funcin main():
void main(void){
char lista [MAX][LONGE], *plista[MAX];
int n;
n = leer (lista, plista);
ordenar (lista, plista, n);
imprimir (plista, n);
}

PGINA: 10