Fflush

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]) {
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 {
29. }
30. } else {
34.
35. return 0;
36. } printf("\nEl menor es %s con una edad de %d",Nombre[0],Edad[0]);
37. } else {
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' };

}
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' };

}
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"

Fflush

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Fflush

Caricato da

Copyright:

Formati disponibili

Fflush

printf( "Introduzca primer caracter: " );

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

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

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

/* Inicio del anidamiento */

Introduzca un numero entero: 7

La tabla de multiplicar del 7 es:

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

Introduzca un numero entero: -12

La tabla de multiplicar del -12 es:

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

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

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

/* Inicio del anidamiento */

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

} while ( seguir != 'n' );

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

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

Ejemplo: Partiendo de la variable:

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

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

Ejemplo 1: Declaradas las variables:

se pueden escribr las instrucciones de expresión:

Dichas instrucciones son equivalentes a:

Y también se pueden escribir como:

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

Ejemplo 2: A partir de las variables:

Si se ejecutan las instrucciones:

Los valores de las variables en memoria serán:

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

printf("Introduce tu numero: ");

while (z < 20)

int DigitosNumeros(int Numero)

Ejercicio sencillo de cadena:

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

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

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

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

El programa anterior sería equivalente a:

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

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

char nombre[8] = "Gandalf";

Funciones de manejo de cadenas

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

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

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

strcpy( destino, texto );

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

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

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

strcpy( nombre_completo, nombre );

Funciona de manera similar a printf pero, en vez de mostrar el texto en la pantalla, lo

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

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

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

 < 0 si cadena1 < cadena2

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

Comparación con strcmp : 1

int error( int num_err )

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

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

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