Fflush

Descargar como docx, pdf o txt
Descargar como docx, pdf o txt
Está en la página 1de 21

Fflush

#include <stdio.h>

int main()
{
char a, b, c;

printf( "Introduzca primer caracter: " );


scanf( "%c", &a );
printf( "Introduzca segundo caracter: " );
fflush( stdin );
scanf( "%c", &b );
printf( "Introduzca tercer caracter: " );
fflush( stdin );
scanf( "%c", &c );
printf( "Los valores son: %c, %c, %c ", a, b, c );

return 0;
}

La primera vez que se ejecuta scanf, el buffer del teclado está vacío, por tanto, no es
preciso utilizar fflush, pero sí, en los dos casos posteriores. Obsérvese que, a fflush hay
que indicarle el buffer a limpiar, Standar Input (stdin) en este caso.

Switch

La sentencia switch() en Lenguaje C es una sentencia de selección. Esta sentencia


permite seleccionar las acciones a realizar de acuerdo al valor que tome una variable.
Modo de uso:
switch(variable)
{
case valor_1:
//acciones
break;
case valor_2:
//acciones
break;
.
.
.
case valor_n:
//acciones
break;
defalut:
//acciones
break;
}
Si el valor que toma la variable no coincide con los valores especificados en los casos, se
realizarán las acciones definidas en la etiqueta default.
For

Si necesitamos repetir un grupo de acciones un número conocido de veces la mejor


opción es la sentencia repetitiva for().
for() es una de las sentencias repetitivas más usadas en los lenguajes de programación,
esta sentencia inicializa una variable, evalúa una condición y luego realiza una operación
sobre una variable.
Modo de uso:
for(inicialización;condición;operacion)
{
//Acciones
}
Secuencia:
1. Se inicializa la variable.
2. Se evalúa la condición.
3. Si la condición se cumple, se realizan las acciones especificadas, si no se cumple,
no se ejecuta ninguna acción y se salta a la próxima línea.
4. Se realiza una operación sobre una variable (incremento, decremento).
5. Se repiten los pasos 2, 3 y 4 mientras se cumpla la condición.
Escriba un programa en lenguaje C que solicite el ingreso un número entero y que
muestre la tabla de multiplicar del mismo.
Solución:
#include <stdio.h>
void main()
{
//Declaración de variables
int numero, i, producto;
//Solicitando y leyendo el ingreso de datos desde el teclado
printf("Ingrese un numero: ");
scanf("%d",&numero);
for(i=0;i<=12;i++)
{
producto=i*numero;
printf("%d x %d = %d\n",numero,i,producto);
}
}

Anidar ciclos

En lenguaje C, para anidar un bucle for en un bucle do while, se utiliza la sintaxis:

do
{

/* Inicio del anidamiento */


for ( <expresión_1> ; <expresión_2> ; <expresión_3> )
{
<bloque_de_instrucciones>
}
/* Fin del anidamiento */

} while ( <expresión_lógica> );

Ejemplo: Se quiere escribir un programa que muestre por pantalla la tabla de multiplicar
de un número entero introducido por el usuario. El proceso debe repetirse mientras que el
usuario lo desee:

Introduzca un numero entero: 7

La tabla de multiplicar del 7 es:

7*1=7
7 * 2 = 14
7 * 3 = 21
7 * 4 = 28
7 * 5 = 35
7 * 6 = 42
7 * 7 = 49
7 * 8 = 56
7 * 9 = 63
7 * 10 = 70

¿Desea ver otra tabla (s/n)?: s

Introduzca un numero entero: -12

La tabla de multiplicar del -12 es:

-12 * 1 = -12
-12 * 2 = -24
-12 * 3 = -36
-12 * 4 = -48
-12 * 5 = -60
-12 * 6 = -72
-12 * 7 = -84
-12 * 8 = -96
-12 * 9 = -108
-12 * 10 = -120

¿Desea ver otra tabla (s/n)?: n

En lenguaje C, para resolver este problema se puede escribir:

#include <stdio.h>

int main()
{
char seguir;
int i, numero;

do
{
printf( "\n Introduzca un numero entero: " );
scanf( "%d", &numero );

printf( "\n La tabla de multiplicar del %d es:\n", numero );

/* Inicio del anidamiento */


for ( i = 1 ; i <= 10 ; i++ )
{
printf( "\n %d * %d = %d",
i, numero, i * numero );
}
/* Fin del anidamiento */

printf( "\n\n Desea ver otra tabla (s/n)?: " );


fflush( stdin );
scanf( "%c", &seguir );

} while ( seguir != 'n' );

return 0;
}

Pow
En lenguaje C, para realizar operaciones con potencias se utiliza una función de su
biblioteca estándar, en concreto la función pow, a la que hay que "darle" (pasarle) dos
operandos entre paréntesis. La sintaxis de su llamada es:

pow( <operando_número_base>, <operando_exponente> )

La función pow devuelve, sobre el propio identificador de la función, el resultado que se


obtiene de elevar el <operando_número_base> al <operando_exponente>. El valor de
retorno de la función es de tipo double, con independencia de que los operandos sean
reales o enteros.

Ejemplo: Partiendo de la variable:

En lenguaje C:

int numero = 9;

De la expresión:

En pseudocódigo:
1 + numero ** 2

En lenguaje C:

1 + pow( numero, 2 )

La función pow devuelve el resultado de elevar el valor de la variable numero a 2. De


manera que, el resultado de evaluar la expresión anterior es:

82.000000 (se obtiene de 1 + 81.000000)

La declaración de la función pow se encuentra en el archivo de cabecera math.h. Por


tanto, si en un programa se utiliza dicha función, habrá que escribir también:

#include <math.h>
++ --
En lenguaje C, tanto el operador incremento (++) como el operador decremento (--) actúan siempre
sobre un solo operando, normalmente una variable. Por tanto, son operadores monarios, y sirven
para incrementar o decrementar en una unidad el valor de dicho operando.

Ejemplo 1: Declaradas las variables:

int r = 8, s = 3;

se pueden escribr las instrucciones de expresión:

r++;
s--;

Dichas instrucciones son equivalentes a:

r = r + 1;
s = s - 1;

Y también se pueden escribir como:

++r;
--s;

Tras su ejecución, el aspecto de la memoria será:


En estas instrucciones, ambos operadores se pueden escribir, indistintamente, antes o después de
los operandos sobre los que actúan. Pero, cuando en una expresión, además del operador
incremento o decremento, también aparecen otros operadores, entonces sí que hay que tener en
cuenta la diferencia que supone el escribirlos antes o después.

Ejemplo 2: A partir de las variables:

int i = 5, j, k = 5, m;

Si se ejecutan las instrucciones:

j = i++;
m = ++k;

Los valores de las variables en memoria serán:

Obsérvese que, los valores de j y m son diferentes. Esto es debido a que, cuando se evalúa la
expresión j = i++, en primer lugar, se le asigna a j el valor de i (es decir, un 5) y, a continuación, se
incrementa el valor de la variable i. Por el contrario, cuando se evalúa la expresión m = ++k,
primero, se incrementa el valor de k (de 5 pasa a ser 6) y, después, este nuevo valor de k se le
asigna a m.
En resumen, cuando en una expresión el operador incremento (++) o decremento (--) precede al
operando sobre el que actúa (por ejemplo ++k), antes de utilizar el valor de dicho operando para
otro propósito, este se incrementa. De ser al revés, es decir, si es el operando quien precede al
operador (por ejemplo i++), el valor de dicho operando se incrementa después de ser utilizado para
otro fin.

Números primos

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[]) {
int num1,i,a;
char resp;
do{
a=0; /*Esta variable la vamos a usar para contar los divisores del número introducido, la
inicializamos a 0*/
fflush( stdin );
printf("Introduce un numero: ");
scanf("%d",&num1);
for(i=1;i<=num1;i++)
{
if(num1%i==0) // si num1 módulo de i es 0, incrementamos a en 1.
a++;
}
if (a==2) { //si al final a vale 2 es primo porque tiene 2 divisores
printf("\nEs primo");
} else {
printf("\nNo es primo");
}
fflush( stdin );
printf("\n\nDesea introducir otro número S/N: ");
scanf ("%c",&resp);
printf("\n\n");
}while (resp=='s' || resp=='S');
return(0);
}

Números felices

#include <stdio.h>
#include <math.h>

int DigitosNumeros(int Numero); // Separa el numero en digitos


int Numeros[10] = {0};
int main()
{
int Numero = 0;

printf("Introduce tu numero: ");


scanf("%i", &Numero);

if (Numero < 0)
{
printf("Introduce un numero valido.\n");
}else{
int i = 0;
int suma = 0;
int z = 0;

while (z < 20)


{
DigitosNumeros(Numero);

suma = 0;
for (i = 0; i < 10; i++)
{
suma = suma + Numeros[i];
}

if (suma == 1)
{
printf("Numero Feliz :)\n");
return 0;
}

suma = 0;
for (i = 0; i < 10; i++)
{
suma = suma + pow(Numeros[i], 2);
}

Numero = suma;
memset(Numeros,0,40);
z++;
}
printf("El numero NO es feliz :(\n");
}
return 0;
}

int DigitosNumeros(int Numero)


{
int i = 0;
int n;
while(Numero > 0)
{
Numeros[i] = Numero % 10;
Numero = Numero / 10;
i++;
}
return 0;
}

Secuencia de Fibonacci

#include <stdio.h>
#include <stdlib.h>
int main(int argc, char *argv[])
{
int n=0, o, serie, m, k, b,q,w,e,r,t,y,u;
printf("Elija la opcion deseada\n");
printf("\n1.- Generar serie de 5 numeros \t");
printf("\n2.- Generar serie de 12 numeros\t");
printf("\n3.- Salir\t");
scanf("%d", &o);
if (o==1)
{
for (n=0; n<2; ++n)
{
serie=n;
n=serie+1;
m=n+serie;
b=m+n;
k=b+n;
printf("\n\n\n");
printf("%d", serie);
printf("%d", n);
printf("%d", m);
printf("%d", b);
printf("%d", k);
}
}
if (o==2)
{
for (n=0; n<2; ++n)
{
serie=n;
n=serie+1;
m=n+serie;
b=m+n;
k=b+n;
q=k+b;
w=q+k;
e=w+q;
r=e+w;
t=r+e;
y=t+r;
u=y+t;
printf("\n\n\n");
printf("%d-", serie);
printf("%d-", n);
printf("%d-", m);
printf("%d-", b);
printf("%d-", k);
printf("%d-", q);
printf("%d-", w);
printf("%d-", e);
printf("%d-", r);
printf("%d-", t);
printf("%d-", y);
printf("%d", u);
}
}
if (o==3)

printf("\n\nHasta pronto");

getchar();
getchar();
return 0;
}

Ejercicio sencillo de cadena:

#include <conio.h>
#include <stdio.h>

void main()
{
int edad;
char nombre[20], sexo;

printf("Nombre :");
scanf("%s",&nombre);

printf("Edad :");
fflush(stdin); //limpiar el buffer del teclado

scanf("%d",&edad);

printf("Sexo :");
fflush(stdin); //limpiar el buffer del teclado

scanf("%c",&sexo);

printf("\n***datos***");
printf("\nNombre: %s", nombre);
printf("\nEdad: %d", edad);
printf("\nSexo: %c", sexo);

getch(); //pausa
}

Un ejercicio en el cual se ha de solicitar tres nombres por pantalla y tres edades, a


continuación determinar cuál es el mayor, mediano y menor, visualizando el
resultado en ese orden.

1. #include <stdio.h>
2. #include <stdlib.h>
3.
4. int main()
5. {
6. char Nombre[3][50];
7. int Edad[3];
8. int Contador=0;
9.
10.
11. // Solicitar las tres edades y nombres
12. for( Contador=0;Contador<3;Contador++ ) {
13. printf("Nombre ...: ");
14. scanf(" %[^\n]",Nombre[Contador]);
15. printf("Edad .....: ");
16. scanf(" %d",&Edad[Contador]);
17. }
18.
19. // Diferenciar al mayor
20. if(Edad[0]>Edad[1]) {
21. if(Edad[0]>Edad[2]) {
22. printf("\nEl mayor es %s con una edad de %d",Nombre[0],Edad[0]);
23. printf("\nEl mediano es %s con una edad de %d",Nombre[2],Edad[2]);
24. printf("\nEl menor es %s con una edad de %d",Nombre[1],Edad[1]);
25. } else {
26. printf("\nEl mayor es %s con una edad de %d",Nombre[2],Edad[2]);
27. printf("\nEl mediano es %s con una edad de %d",Nombre[0],Edad[0]);
28. printf("\nEl menor es %s con una edad de %d",Nombre[1],Edad[1]);
29. }
30. } else {
31. if(Edad[1]>Edad[2]) {
32. printf("\nEl mayor es %s con una edad de %d",Nombre[1],Edad[1]);
33. printf("\nEl mediano es %s con una edad de %d",Nombre[2],Edad[2]);
34.
35. return 0;
36. } printf("\nEl menor es %s con una edad de %d",Nombre[0],Edad[0]);
37. } else {
38. printf("\nEl mayor es %s con una edad de %d",Nombre[2],Edad[2]);
39. printf("\nEl mediano es %s con una edad de %d",Nombre[1],Edad[1]);
40. printf("\nEl menor es %s con una edad de %d",Nombre[0],Edad[0]);
41. }

Cadenas
Vamos ahora a ver cómo manejar texto con C. Para empezar, es preciso decir que existe
un tipo string como en otros lenguajes, pero no existe un tipo de datos específico para
almacenar texto, sino que se utilizan arrays de char. Funcionan igual que los
demás arrays con la diferencia de que ahora se manejan letras en vez de números. Se les
llama cadenas, strings o tiras de caracteres y a partir de ahora les llamaremos cadenas.

Para declarar una cadena se hace como en el caso de un array. Por ejemplo, si queremos
declarar una cadena de longitud 20 caracteres se haría:

char texto[20];

Al igual que en los arrays, no podemos entonces introducir más de 20 elementos en la


cadena. Vamos a ver un ejemplo para mostrar el nombre del usuario en pantalla:

#include <stdio.h>

main()
{
char nombre[20];

printf( "Introduzca su nombre (20 letras máximo): " );


scanf( "%s", nombre );
printf( "\nEl nombre que ha escrito es: %s\n", nombre );
}

Obsérvese que en la sentencia scanf no se usa el símbolo & delante de nombre. No hace
falta porque se trata de un array, de modo que escribir el nombre del array es equivalente
a poner &nombre[0].

También puede llamar la atención sobre la forma de imprimir el array. Con sólo
usar %s ya se imprime su totalidad. Ya veremos esto más adelante.

Por si alguien está acostumbrado a programar en otro lenguaje es preciso hacer notar que
en C no se puede hacer esto:

#include <stdio.h>

main()
{
char texto[20];

texto = "Hola";
}

Es interesante saber cómo funciona una cadena por dentro, por eso vamos a ver primero
cómo se inicializa:

#include <stdio.h>
main()
{
char nombre[] = "Gandalf";

printf( "Texto: %s\n", nombre );


printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}

Resultado al ejecutar:

Texto: Gandalf
Tamaño de la cadena: 8 bytes

Curiosamente la respuesta nos dice que "Gandalf" ocupa 8 bytes. Como cada
elemento char ocupa un byte eso quiere decir que la cadena tiene 8 elementos, a pesar
de que "Gandalf" sólo cuenta con 7 letras. La razón de esta aparente paradoja estriba en
que la cadena tiene como carácter final el símbolo '\0', cuyo significado es "fin de cadena".
De esta forma, cuando queremos escribir la cadena basta con usar %sy el compilador
sabe cuántos elementos debe escribir: hasta que encuentre '\0'.

El programa anterior sería equivalente a:

#include <stdio.h>

main()
{
char nombre[] = { 'G', 'a', 'n', 'd', 'a', 'l', 'f', '\0' };

printf( "Texto: %s\n", nombre );


printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}

Aquí ya se observa claramente que nombre tiene 8 elementos. Pero, ¿qué pasaría si no
pusiéramos '\0' al final?

#include <stdio.h>

main()
{
char nombre[] = { 'G', 'a', 'n', 'd', 'a', 'l', 'f' };

printf( "Texto: %s\n", nombre );


printf( "Tamaño de la cadena: %i bytes\n", sizeof nombre );
}

En mi ordenador se obtiene:

Texto: Gandalf-
Tamaño de la cadena: 7 bytes

Pero en otro después de "Gandalf" puede aparecer cualquier cosa. Lo que aquí sucede es
que printf no encuentra el símbolo '\0' y no sabe cuándo dejar de imprimir.
Afortunadamente, cuando introducimos una cadena se hace de la primera forma y el C se
encarga de poner el símbolo al final.

Es importante no olvidar que la longitud de una cadena es la longitud del texto más el
símbolo de fin de cadena. Por eso cuando definamos una cadena tenemos que reservarle
un espacio adicional. Por ejemplo:

char nombre[8] = "Gandalf";

Funciones de manejo de cadenas

Existen unas cuantas funciones en la biblioteca estándar de C para el manejo de


cadenas:

 strlen
 strcpy
 strcat
 sprintf
 strcmp

Para usar estas funciones en nuestro programa hay que añadir la directiva:

#include <string.h>

strlen
size_t *strlen(const char *cadena);

Esta función devuelve el número de caracteres que tiene la cadena (sin contar el '\0').

#include <stdio.h>
#include <string.h>

main()
{
char texto[]="Gandalf";
int longitud;
longitud = strlen(texto);
printf( "La cadena \"%s\" tiene %i caracteres.\n", texto, longitud );
}

Como ejemplo, vamos a ver cómo se programaría esta función si no dispusiéramos de


ella.
#include <stdio.h>
#include <string.h>

main()
{
char texto[]="Gandalf";
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 condición 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 lo que pasamos a la siguiente
letra).

strcpy 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>

main()
{
char texto[] = "Éste es un curso de C.";
char destino[50];

strcpy( destino, texto );


printf( "Valor final: %s\n", destino );
}

Vamos a ver otro ejemplo en el que la cadena destino es una cadena constante ("Éste es
un curso de C.") 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 destino[50]="Éste no es un curso de HTML, sino de C.";

printf( "%s\n", destino );


strcpy( destino, "Éste es un curso de C." );
printf( "%s\n", destino );
}

strcat

char *strcat(char *cadena1, const char *cadena2);

Añade la cadena2 al final de la cadena1 (concatena).

#include <stdio.h>
#include <string.h>

main()
{
char nombre_completo[50];
char nombre[]="Gandalf";
char apellido[]="el Gris";

strcpy( nombre_completo, nombre );


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

Como siempre, tenemos asegurar que la variable en la que añadimos las demás cadenas
tenga el tamaño suficiente. Con la primera línea de este programa introducimos el nombre
en nombre_completo. Usamos strcpy para asegurarnos de que queda borrado cualquier
dato anterior. Luego usamos un strcat para añadir un espacio y, finalmente, introducimos
el apellido.

sprintf
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 número de caracteres
guardados en la variable destino.

Con sprintf podemos repetir el ejemplo de strcat de manera más sencilla:

#include <stdio.h>
#include <string.h>
main()
{
char nombre_completo[50];
char nombre[]="Gandalf";
char apellido[]="el Gris";

sprintf( nombre_completo, "%s %s", nombre, apellido );


printf( "El nombre completo es: %s.\n", nombre_completo );
}

Se puede aplicar a sprintf todo lo indicado para printf.

strcmp int strcmp(const char *cadena1, const char *cadena2);

Compara cadena1 y cadena2. Si son iguales, devuelve 0. Un número negativo


si cadena1 "va" antes que cadena2, y un número positivo si es al contrario:

 < 0 si cadena1 < cadena2


 ==0 si cadena1 == cadena2
 > 0 si cadena1 > cadena2

#include <stdio.h>
#include <string.h>

main()
{
char nombre1[]="Gandalf";
char nombre2[]="Frodo";

printf( "Comparación con strcmp: %i\n", strcmp(nombre1,nombre2));


}

El resultado es:

Comparación con strcmp : 1

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 número.

#include <stdio.h>
#include <string.h>

int error( int num_err )


{
char *errores[] = {
"No se ha producido ningún error",
"No hay suficiente memoria",
"No hay espacio en disco",
"Me he cansado de trabajar"
};

printf( "Error número %i: %s.\n", num_err, errores[num_err] );


exit( -1 );
}

main()
{
error( 2 );
}

El resultado será:

Error número 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 ningún error") tiene un espacio reservado en memoria
y errores[0] apunta a ese espacio.

o Ordenación de un array de cadenas

Vamos a ver un sencillo ejemplo de ordenación de cadenas. En el ejemplo siguiente


tenemos que ordenar una serie de dichos populares:

#include <stdio.h>
#include <string.h>

#define ELEMENTOS 5

main()
{
char *dichos[ELEMENTOS] = {
"La avaricia rompe el saco",
"Más vale pájaro en mano que ciento volando",
"No por mucho madrugar amanece más temprano",
"Año de nieves, año 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=i+1; 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] );
}

Cómo funciona el programa:

 tomamos el primer elemento de la matriz. Lo comparamos con todos los


siguientes. Si alguno es anterior, los intercambiamos. Cuando acabe esta primera
vuelta tendremos "A caballo regalado no le mires el diente" en primera posición.
 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 posición.

Para ver con mayor claridad el resultado a partir del desarrollo del proceso, se va a
sustituir cada cadena por su primera letra (menos la de "Año de nieves..." que se
sustituirá por Añ). Así, el proceso queda:

0 1 2 3 3' 4 4' 5 6 6' 7 7' 8 8' 9 9' 10 10'


1 L L L L Añ Añ A
2 M M M M M M M M M L L Añ
3 N N N N N N N N N N N N N M M L
4 Añ Añ Añ Añ L L L L L M M M M N N N N M
5 A A A A A A Añ Añ Añ Añ Añ L L L L M M N

Recorrido de cadenas con punteros

Las cadenas se pueden recorrer de igual forma que se hace con los arrays, usando
punteros. Vamos a ver un ejemplo: el siguiente sencillo programa cuenta los espacios y
las letras e (minúsculas) que hay en una cadena.

#include <stdio.h>
#include <string.h>

main()
{
char cadena[]="El puerto paralelo del PC";
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 );
}

El resultado es:

En la cadena "El puerto paralelo del PC" hay:


4 espacios
3 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 dirección del primer elemento de
la misma. El valor de *p sería, por tanto, 'E'. Comenzamos el bucle. La condición
comprueba que no se ha llegado al final de la cadena (*p != '\0'). Entonces se comprueba
si en la dirección a la que apunta p hay un espacio o una letra e. Si es así, se incrementan
las variables correspondientes. Una vez comprobado esto se pasa a la siguiente letra
(p++).

En este otro ejemplo substituimos los espacios por guiones:

#include <stdio.h>
#include <string.h>

main()
{
char cadena[]="El puerto paralelo del PC";
char *p;

p = cadena;
while (*p != '\0') {
if (*p == ' ') *p = '-';
p++;
}

printf( "La cadena queda: \"%s\" \n", cadena );


}

y se obtiene:

La cadena queda: "El-puerto-paralelo-del-PC"

También podría gustarte