Curso de iniciación en programación C

[Blanquito]

3.6- Ejercicios

1- Verdadero o Falso

a) Una constante puede cambiar de valor a lo largo del programa.
b) El tipo int permite sistema octal.
c) Double tiene más precisión de decimales que float.
d) El tipo void es para carateres.
e) Declarando constantes con #define, estás reservando memoria para ellas.
f) Depués de declarar un variable siempre se pone punto y coma.

2- Di qué identificadores son incorrectos.

a) _pulsacion
b) año
c) auto
d) Tuyo
e) YaYo
f) num_camiones
g) #numero
h) mi_edad
i)  19registro
j)  cod soft

#include <stdio.h>
#define MAYORIA_EDAD 18; ¿No es sin punto y coma?

int main (void){
int Edad_Juanito, Edad_Novia_Juanito;
char opc;
printf ("¿Cuántos años tiene Juanito?");
scanf ("%d", &Edad_Juanito);
printf ("¿Y su novia?");
scanf ("%d", &Edad_Novia_Juanito);

if (Edad_Juanito >= MAYORIA_EDAD){
printf("Juanito es mayor de edad");}

While ("mundo" == "mundo"){
printf ("¿Ha pasado un año? (S/N)");
scanf ("%c", &opc);

if (opc == 'S'){
int edad_Juanito ++;
Edad_Novia_Juanito ++; ¿Sería int Edad_Novia_Juanito ++? O despues de int edad_Juanito ++ con coma, ¿no?
}
}
}

Lo de para qué funciona y tal ni idea, chacho.

[Thylzos]

Blanquito estuvo mucho más cerca . Tienes las soluciones en la página anterior.

[Blanquito]

Soy el primero de la clase ray.

[Thylzos]

Venga, que no tengo nada que hacer y Sandman quiere que posteemos:

4- Operadores

4.1 Definiciones

-Operador: Elemento utilizado en un lenguaje de programación a fin de realizar una operación con variables.

-   Operador aritmético: Operador utilizado para realizar tratamientos matemáticos a dos variables (suma, resta, etc.).

-   Operador de asignación: Operador utilizado para dar el resultado de una expresión a una variable.

-   Operador de asignación compuesto: Operador de asignación que nos simplifica la programación abreviando expresiones.

-   Operador de incremento y de decremento: Operadores encargados de aumentar o disminuir, respectivamente, en uno una variable.

-   Operador de bit: Realizan una operación sobre cada uno de los bits de un int o un char.

-   Operador relacional: Operador encargado de evaluar la relación de dos valores.

-   Operador lógico: Operador encargado de evaluar lógicamente uno o dos valores.


4.2 – Operadores aritméticos

En esta familia nos encontramos con cinco posibilidades:

    +      Suma           
    -      Resta, negación
    *      Multiplicación 
    /      División       
    %      Resto de la div.

No creo que haga falta que explique los cuatro primeros (sería preocupante). En cuanto al quinto, nos da como resultado el resto de la división entre dos números, así la expresión "22%3" daría 1.

Veamos ejemplos:

Código [Seleccionar] Expandir

int main (void){

int v, w, x, y, z ;

const int K=10;

v = K+1; /* Suma la constante K y 1, para almacenarlo en v*/
w = v-K; /* Resta v y K y almacena el resultado en w*/
x = w*v; /* Multiplica w y v y lo almacena en x*/
y = w/x;  /* divide w entre x y lo almacena en y*/
z = y%x; /* Dvide y entre x y el resto lo almacena en z*/
}[code]

Además podemos utilizar + y – como signos negativo y positivo. Veamos un ejemplo:

[code]int main (void) {

int v, w ;
const int K=10;
x = -K+2;
y = -x*3;
}

Amable lector, corre, llama a tu madre y anúnciale que acabas de aprender a sumar y restar.

4.3 – Operadores de asignación

Operadores de asignación simple, únicamente tenemos el signo igual ( = ). Y con éste solo ya haremos maravillas. Como ya dije, sirve para darle a una variable el resultado de una expresión. Su sintaxis es:

Variable = expresión;

Primero se pone el identificador de la variable que almacenará el resultado, un signo igual y la expresión que puede o no contener otra o esa variable. Veamos un ejemplo:

Código [Seleccionar] Expandir

int main (void) {
int x, y ;
x = 0; /* x vale 0*/
x = 2; /* Ahora 2 */
x = x + 2; /* Ahora es 4 */
y = x * 2; /* y es igual a 8 */
y = y + 1; /* y es igual a 9 */
}

Pero esto no es todo. Además podemos usar caracteres. Recordemos que un carácter es un símbolo con un valor numérico en un juego de caracteres como el ASCII. Veamos entonces un ejemplo:

Código [Seleccionar] Expandir

int main (void) {
char letra;
letra = 'B' ; /* 'B' es el carácter número 66 en el código ASCII*/
letra = letra – 1; /* Ahora disminuímos uno, es decir, letra vale 65 que es 'A'*/
letra = letra – 1; /* Volvemos a disminuir uno, valiendo letra 64 que no me acuerdo que carácter era en el ASCII */
}

Y hay más, podemos utilizar varios = en una misma línea, como en éste caso:

Código [Seleccionar] Expandir

int main (void) {
int a, b, c, d ;
a = b = c = d  = 0;
}

Ahora tanto a, como b, como c, como d valen 0 .

4.4 – Operadores de asignación compuestos

En muchas ocasiones usaremos expresiones del estilo de:

Variable_1 = Variable_1 + 3;
Variable_2 = Variable_2 – 3;

Donde la sintaxis:

Variable = Variable operador expresión;

La variable situada a  ambos lados es la misma. Pues bien, C nos da la oportunidad de simplificar esto. Para hacerlo usaremos esta sintaxis:

variable operador = expresión;

Como siempre, veamos ejemplos:

Código [Seleccionar] Expandir

int main (void) {
int a, b;
a += b; /* Es igual a: a = a + b; */
a *= b; /* Es igual a: a = a * b; */
a >>=  b; /* Es igual a: a = a>>b: */
a &= b; /* Es igual a: a = a&b; */
}

4.5 - Operadores de incremento y decremento.

Cuando lo único que quieres hacer es sumar o restar 1 a una variable, escribimos:

variable = variable + 1;
variable = variable - 1;

o:

variable += 1;
variable -= 1;

Es un poco engorroso para los vagos como yo, para eso tenemos:

++ variable;
variable ++;
-- variable;
variable --;

Y es tan fácil como parece. Sólo con eso ya habremos incrementado o decrementado en uno una variable. Pero, veamos con atención este ejemplo:

Código [Seleccionar] Expandir

int main (void) {
int a ;
int x = 10 ;
a = x++ ;
a = ++x ;
a = x--;
a = --x;
}

En la primera línea primero le damos a 'a' el valor de 'x' (a  = 10) y después aumentamos 'x' en uno (a = 11). En la segunda, primero aumentamos 'x' (x = 12) y después guardamos en 'a' (a = 12). En la tercera, primero guardamos (a = 12), luego disminuimos (b = 11). En la cuarta, primero disminuímos (b = 10) y después guardamos (a = 10).

Como podemos ver, en x++ primero se utiliza el valor de la variable (se guarda en a) y después se incrementa. Y en ++x es justo al revés.

4.6 – Operadores de bits.

Como ya sabemos, estos operadores funcionan sólo con char e int. Y como también sabemos lo hacen a nivel de bits. Estos son:

-   AND, representado con &.
-   OR, representado con |.
-   XOR, representado con ^.
-   Complemento a uno, representado con ~.
-   Desplazamiento hacia la izquierda, representado con <<.
-   Desplazamiento hacia la derecha, representado con >>.

Voy a dar por supuesto que saben binario, pero si alguien no lo conoce, que consulte este link: http://www.templobinario.com/index.php?mdl=la&ida=31#.

Con AND comparamos bit a bit dos variable con resultados dependientes de la siguiente tabla:

Bit 1    /    Bit 2    / Resultado

0       /       0        /      0
0       /      1        /      0
1       /       0        /      0
1       /       1        /      1
Así, 72 (1001000) AND 29 (0011101) es igual a 16 (0001000).

Con OR es lo mismo pero con esta tabla:

Bit 1    /    Bit 2    / Resultado

0       /       0        /      0
0       /      1        /       1
1       /       0        /      1
1       /       1        /      1

Por ejemplo, 72 (1001000) OR 29 (0011101) es igual a 93 (1011101).

Con XOR, según su correspondiente tabla:

Bit 1    /    Bit 2    / Resultado

0       /       0        /      0
0       /      1        /       1
1       /       0        /      1
1       /       1        /      0

Otro ejemplo, 72 (1001000) XOR 29 (0011101) es igual a 85 (1010101).

El de complemento a uno (o NOT) invierte los bits de una variable.

Así ~72 (1001000) es igual a 55 (0110111).
Si a alguien le interesa profundizar en el tratamiento de bits y el álgebra booleana, visite: http://www.monografias.com/trabajos14/algebra-booleana/algebra-booleana.shtml

Ahora vamos a los desplazamientos. Desplazamiento a la izquierda (<<) desplaza los bits hacia la izquierda tantas posiciones como se indique tras el operador, colocando el bit del final en cero, y el bit del principio eliminándolo. Ejemplo:

Código [Seleccionar] Expandir

int main (void) {
int izquierda = 1 ;
izquierda = izquierda >> 1;
}

La variable izquierda vale 1 (00000001). Al desplazar a la izquierda, el primero se desecha (0000001) y ponemos un cero al final (00000010), ahora izquierda vale 2.

El desplazamiento derecha desplaza los bits hacia la derecha tantas posiciones como se indique al final del operador, transformando el bit del principio en 0 y el del final se desecha.

Segundo ejemplo:

Código [Seleccionar] Expandir

int main (void) {
int derecha = 1 ;
derecha = derecha >> 1;
}

Ahora desechamos el  bit del final, pasando de 00000001 a 0000000, y luego ponemos un cero al final 00000000, valiendo ahora derecha 0.

4.7 – Operadores relacionales

Este tipo de operaciones se utilizan para evaluar una relación entre dos expresiones dando como resultado el valor verdadero o el falso. Estos son los operadores relacionales:

Acción  / Operador
Mayor que /  >
Mayor o igual que / >=
Menor que / <
Menor o igual que / <=
Igual / =
Distinto /  !=

Veamos ejemplos:
m == n -> ¿es m igual que n? -> Falso
m != n -> ¿es m distinto que n? -> Verdadero
m > n -> ¿es m mayor que n? -> Falso
m < n -> ¿es m menor que n? -> Verdadero
m >= n -> ¿es m mayor o igual que n? -> Falso
m <= n -> ¿es m menor o igual que n? -> Verdadero

4.8- Operadores lógicos

Bien estos evaluan de forma lógica, puede ser de uno o de dos valor, el NOT lo hace con uno y el AND y el OR con dos.

Operador / Acción
&& / Conjunción (Y)
|| / Disyunción (O)
! / Negación

El resultado de estas operaciones obedece las tablas que vimos antes, la de AND con la tabla de AND y la de OR con la de OR, y se interpreta así: 1 es verdadero y 0 falso. En el caso de NOT, si es verdadero es falso y si falso es verdadero. Tengan en cuenta que 0 siempre es falso y el resto de los números verdadero. Para entenderlo mejor, veamos ejemplos:

27 && -15 -> verdadero AND verdadero -> verdadero
0&&0 -> falso AND falso -> Falso
1&&0,0001 -> Verdadero AND verdadero -> verdadero
-2 || 100 -> Verdadero OR verdadero -> verdadero
0||0 -> falso OR falso -> Falso
! 0 -> Negación de falso -> verdadero
! 2 -> negación de verdadero -> Falso

Podemos combinar operadores relacionales con los lógicos, por ejemplo:

(7>3) && (12<=30)

La expresión se resuelve empezando por los paréntesis. ¿7 es mayor que 3? Sí, así que el primer resultado es verdadero. ¿12 es menor o igual que 30? Sí, entonces el resultado del segundo paréntesis es verdadero. Para terminar se calcularía la expresión del resultado obtenido en cada paréntesis con un AND:

Verdadero && Verdadero

Lo que nos de verdadero como resultado de la expresión.

4.9 - Operador de conversión explícita (cast) [Cortesía de Hartigan]

Se utiliza el operador cast, el cual proviene de la terminología inglesa casting. Realiza una conversión explícita de tipos, es decir, consiste en "obligar" a una variable o expresión a ser temporalmente de un determinado tipo mientras se evalúa en una expresión.
Ésto consiste en dar un nombre de "tipo" encerrado entre paréntesis que precederá a la variable o expresión la cual queramos convertir.
Hay que tener cuidado ya que el operador cast actúa sobre la variable más próxima.

Veámos todo esto con una serie de ejemplos:

Supongamos que tenemos la siguiente declaración:

float f = 11;

La expresión f % 4 NO es válida porque el operando f es real en vez de entero. Sin embargo la expresión (int) f % 4 hace que el operando se tranforme temporalmente en entero y , por tanto, la expresión ya es válida, y se obtiene como resultado el valor 3 como entero.

Supongamos ahora la expresión siguiente:

f = (9/5)*c +32;

Esa expresión proporcionará un valor incorrecto y no esperado, pues 9/5, al ser los dos operandos enteros, dará como resultado el valor 1 y no el 1.8 deseado.
Para solucionar esto podemos usar una de los siguientes métodos:

f = (9.0 / 5) * c + 32;
f = (9 / 5.0) * c + 32;
f = ((float)9 / 5) * c + 32;

4.10 – Orden de operación de los operadores.

Como debemos de saber, los paréntesis son lo primero que se opera. Pero luego hay que tener en cuenta este orden (ascendente a descendente):

Operador

++       /         Incremento
--         /         Decremento
-          /         Signo negativo
*         /          Multiplicación
/          /          División
%        /          Módulo o resto
+         /          Suma
-          /          Resta

4.11 – Ejercicios

1-   Di si la expresión es verdadera o falsa:

! ((7>=7) || (33>33))
(8<9) && ¡(54>=78 )
! (8!=9) || !(86>=96)

2-   ¿Cuál es el valor de la variable después de estas operaciones?

Código [Seleccionar] Expandir

int main (void){
int x = 3;
x++ ;
x++ ;
x-- ;
x += 3 ;
x -=1 ;
x *= 5;
}

El reto

¿Serías capaz de hacer un programa que incialice una variable, le dé un valor y opere con él con todos los tipos de operadores hasta el final desembarcar en el mismo del principio sin usar operaciones opuestas?, es decir, sin hacer como Juanito, que puso:

Código [Seleccionar] Expandir

int main (void) {
int x = 1 ;
x++ ;
x-- ;
x += 2 ;
x -= 2 ;
x *= 4 ;
x /= 4 ;
}[/code][/code]

[Blanquito]

Buah, para hacer éste voy a tardar unos días porque paso de meterme más cosas en el cerebro que tengo un examen de matemáticas anual y me tengo que aprender muchos teoremas.

[Thylzos]

Buah, para hacer éste voy a tardar unos días porque paso de meterme más cosas en el cerebro que tengo un examen de matemáticas anual y me tengo que aprender muchos teoremas.

¿Todavía tienes clases ?, yo llevo más de una semana libre...

[Blanquito]

En la academia técnica superior. Tengo que ir, ya que apoquino. Y me queda el examen de matemáticas final, el sábado, que soy capaz de aprobar con una matrícula si me aprendo teoremas y demás.

[Thylzos]

En la academia técnica superior. Tengo que ir, ya que apoquino. Y me queda el examen de matemáticas final, el sábado, que soy capaz de aprobar con una matrícula si me aprendo teoremas y demás.

Te deseo matrícula en ese caso.

[Thylzos]

Soluciones del 4º capítulo

1- Di si la expresión es verdadera o falsa:

! ((7>=7) || (33>33)) -> Falso
(8<9) && ¡(54>=78 ) -> Verdadero
! (8!=9) || !(86>=96) -> Verdadero

!((7>=7) || (33>33))

7 es mayor o igual que 7, así que en la primera parte, Verdadero. 33 no es mayor que 33, la segunda parte es Falsa. Verdadero OR Falso = Verdadero. !Verdadero (Verdadero negado) =  Falso, la solución es Falso.

(8<9) && ¡(54>=78 )

8 es menor que 9, con lo que lo primero es Verdadero. 54 no es mayor o igual que 78, así que nos da Falso, pero como a su vez está negado, nos da Verdadero (!Falso = Verdadero). Por último, Verdadero AND Verdadero = Verdadero. El resultado es Verdadero.

!(8!=9) || !(86>=96)

8 es distinto de 9, Verdadero. Pero a su vez está negado y !Verdadero = Falso. 86 no es mayor o igual que 96, resultao Falso que a su vez también está negado y !Falso = Verdadero. Para finalizar, Falso OR Verdadero = Verdadero. Resultado Verdadero.

2- ¿Cuál es el valor de la variable después de estas operaciones?

Código [Seleccionar] Expandir

int main (void){
int x = 3;
x++ ;
x++ ;
x-- ;
x += 3 ;
x -=1 ;
x *= 5;
}

Primero, x =3.
x++ -> x=4
x++ -> x= 5
x-- -> x=4
x += 3 -> x = x + 3 -> x= 7
x -= 1 -> x = x - 1 -> x=6
x *= 5 -> x = x * 5 -> x= 30
Solución: x = 30

En cuanto al reto, hay muchas soluciones, y para no analizar una por una todas, les recomiendo a todos los que lo hayan hecho que para comprobar si estan bien agreguen esto al final a su programa:

Código [Seleccionar] Expandir

#include <stdio.h> /* La biblioteca que vamos a utilizar */

int main (void) {

...  /* La declaración de la variable y los operadores que usó cada uno*/
printf ("Variable al final de las operaciones: %d", nombres de la variable que usaron); /* Para que nos muestre cuánto vale al final del programa */
getchar (); /* Para que nos de tiempo a verlo*/
}

Si el dato que nos muestra al final es el mismo que el que le dimos a la variable al principio, entonces el ejercicio está bien, en caso contrario revisen todo lo que hicieron.

Hasta mañana.

[Thylzos]

5- Entrada/Salida Estándar

5.1- Definiciones

- Entrada de datos: Acción en la que el usuario ingresa datos desde un dispositivo de entrada del ordenador hasta el programa que se esté ejecutando en ese momento. Cuando hablamos de entrada estándar nos referimos a que es por medio del teclado.

- Salida de datos: Acción en la que el ordenador muestra al usuario, a traves de un dispositivo de salida, información obtenida por el programa que se está ejecutando en ese momento. Cuando hablamos de salida estándar nos estamos refiriendo a que es por medio de la pantalla.

5.2- Salida de datos

5.2.1- Salida de caracteres

Para poder mostrar un carácter usaremos la función putchar(); que tiene la siguiente cabecera:

int putchar (int caracter);

No se preocupen si no lo entienden del todo, con el paso de los capítulos quedará más que claro. Por ahora basta con saber cómo interpretarla. Y para eso debemos saber que el parámetro "caracter" es el código del carácter que queremos imprimir en pantalla. Es increíble lo difícil que suena una explicación formal del asunto, pero con este ejemplo veremos lo simple que es:

Código [Seleccionar] Expandir

include <stdio.h> /*ponemos la biblioteca de la función "putchar" para poder usarla*/

int main (void) {
putchar ('A');
getchar ();
}

No creo que sea muy difícil entender qué hace, pero aún así lo explico. Simplemente imprime la letra 'A' y espera que se pulse Enter, así de simple.

Ahora probemos otra alternativa al anterior algoritmo:

Código [Seleccionar] Expandir

include <stdio.h> /*ponemos la biblioteca de la función "putchar" para poder usarla*/

int main (void) {
char letra = 'A';
putchar (letra);
getchar();
}

Y nos da como resultado lo mismo que el anterior. ¿Qué conclusión sacamos de esto?, que también se pueden pasar como caracteres variables del programa, lo que es más útil de lo que parece a simple vista.

5.2.2- Salida de cadenas de caracteres

No sabía si poner o no este apartado, pero como sé que no tiene nada de divertido mostrar un sólo carácter en pantalla, decidí explicar algo aunque sea de la salida de cadenas.

Para eso, nos valeremos de la función puts(); de stdio.h, cuya cabecera, si no recuerdo mal (corríjanme en caso de error, me da pereza buscarla), es:

int puts (char cadena []);

Y utilizarla es igual que con putchar, sólo que como todavía no sabemos cómo guardar cadenas en variables, esta utilidad por ahora no la usaremos. Como de costumbre, veamos un ejemplo:

Código [Seleccionar] Expandir

include <stdio.h> /*ponemos la biblioteca de la función "puts" para poder usarla*/

int main (void) {
puts ("Esto es una prueba");
getchar();
}

Y veremos impreso en pantalla el texto "Esto es una prueba".

5.3- Entrada de caracteres

Antes de nada, vamos a ver un par de conceptos:

- Esperar Intro: Después de introducir un dato a un programa, si la función utilizada posee esta característica, espera a que se pulse Enter para continuar.

- Con eco: Cuando introducimos un dato, si la función utilizada posee esta característica, vemos el dato introducido.

5.3.1- getchar

La función de entrada de caracteres getchar(); es con eco y espera Intro. Pertenece a la biblioteca stdio.h y su cabecera es:

int getchar (void);

Lo que retorna (ese int de ahí ) es el código del carácter escrito, veamos un ejemplo ilustrativo:

Código [Seleccionar] Expandir

#include <stdio.h>

int main (void) {

char letra
letra= getchar ();
putchar (letra);
getchar();
}

Me planteé poner imágenes, pero quedan muy chicas y es lo mismo que nada, así que explicaré qué sucede. Bien, como getchar() tiene eco, cuando pulsamos la tecla del carácter que queremos ingresar, obtenemos que esta se reproduce en pantalla, después tendremos que pulsar Intro para seguir y nos volverá a mostrar la letra (putchar (letra)), para pasar a esperar a que se pulse Intro. en conclusión, nos muestra dos veces (una por getchar y otra por putchar) el carácter entrado.

5.3.2- getch

En este caso, nos encontramos con una función que ni tiene eco ni espera Intro, una auténtica negada (vale, vale, dejo los chistes malos). Su cabecera es:

int getch (void);

La cual, como en el caso anterior, devuelve el código del carácter. Como en el caso anterior, veremos un ejemplo:

Código [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h> /*Biblioteca de getch()*/

int main (void) {

char letra
letra= getch ();
putchar (letra);
getch();
}

Al ejecutarlo e ingresar el dato, sólo nos muestra éste una vez en pantalla (por putchar(letra), debido a que getch() no tiene eco.

Una de las utilidades más interesantes de esta función es la siguiente:

Código [Seleccionar] Expandir

printf ("Pulse una tecla para continuar.");
getch ();

5.3.3- getche

En este caso, nos encontramos con una alternativo que tiene eco, pero que no espera Intro, y cuya cabecera es:

int getche (void);

Como siempre, nos retorna el código del carácter en cuestión, vamos al ejemplo:

Código [Seleccionar] Expandir

#include <stdio.h>
#include <conio.h> /*Biblioteca de la función getche*/

int main (void) {

char letra
letra= getche ();
putchar (letra);
getchar();
}

Como podremos comprobar, en este caso nos imprime dos veces el carácter que ingresamos, pero no espera a que pulsemos Intro una vez pusimos a éste.

5.4- Entrada/Salida formateada

Todo esto muy lindo, pero ¿y si quiero mostrar el valor numérico de una variable? o ¿y si quiero que el usuario ingrese un número no un símbolo de un número (carácter)? o: y si no me gusta el sistema decimal y me manejo con octal, ¿cómo hago para mostrar datos así?. Para todas estas respuestas, existen las Entradas/Salidas formateadas, es decir, que nos permiten distintos formatos para mostrar el dato en cuestión.

5.4.1- Salida formateada (printf)

No voy a poner la cebecera de esta función porque sería marear mucho a los lectores y no es para nada ése el fin. Pero sí voy a explicar cómo funciona:

printf ("cadena_con_formato", [lista_de_argumentos]);

Para entenderlo vamos a poner ejemplos de cada parte (cómo me gustan los ejemplos ¿eh?), primero de cadena_con_formato:

Código [Seleccionar] Expandir

#include <stdio.h>

int main (void) {
printf ("Estoy probando la función printf");
getchar():
}

El resultado es más que previsible. Sin embargo, a esto podemos agregarle caracteres "especiales", que son:

Escape  /   Hexad /    ANSI /    Nombre o resultado
    /   0x00 /   NULL /   Carácter nulo
\a /   0x07 /   BELL /   Sonido de campanilla
\b /   0x08 / BS / Retroceso
\f /   0x0C /   FF /   Avance de página
\n /   0x0A /   LF /   Avance de línea
\r /   0x0D / CR /   Retorno de línea
\t /   0x09 /   HT /   Tabulador horizontal
\v  /   0x0B /   VT /   Tabulador vertical
\\  /   0x5c /   \ /   Barra descendente
\'  /   0x27    '    Comilla sencilla
\"  /   0x22    "    Comillas
\? /   0x3F    ?    Interrogación
\O /        cualquiera /   O=tres dígitos en octal
\xH    /     cualquiera /   H=número hexadecimal
\XH     /    cualquiera /   H=número hexadecimal

Por ejemplo:

Código [Seleccionar] Expandir

#include <stdio.h>

int main (void) {
printf ("Estoy probando la función printf\n\testetexto sale tabulado/"no se entiende lo que pongo.../"");
getchar():
}

Además, y ahora viene lo interesante, podemos poner determinados comandos, los cuales nos permiten poner, por ejemplo, mostrar en pantalla el valor de una variable en binario, para lo que necesitaremos la lista_de_argumentos. Veamos el siguiente programa:

Código [Seleccionar] Expandir

#include <stdio.h>

int main (void) {
int x = 10;
printf ("Estoy probando la función printf, x vale %d", x);
getchar():
}

En pantalla no nos va a mostrar "Estoy probando la función printf, x vale: %d", sino que: "Estoy probando la función printf, x vale: 10". ¿Por qué?, porque cuando pusimos "%d" lo que estabamos diciendo es que queremos mostrar en pantalla el valor en decimal y entero de la primera variable de la lista de argumentos.

Los comando para precisar el formato que vammos a utilizar, se escriben así:

%[anchura]. [precisión] caracter_de_tipo

Donde anchura es el número opcional mínimo de caracteres que tendrá el número a mostrar en pantalla, precisión el número opcional mínimo de decimales tras la coma y caracter_de_tipo el carácter que representa el formato en el cual queremos imprimir el número, estos caracteres son:

Carácter de tipo  /    Entrada esperada /    Formato de salida
Números         
d /   Entero con signo /   Entero decimal
i /   Entero con signo /   Entero decimal
o /   Entero con signo /   Entero octal
u /   Entero sin signo /   Entero decimal
x /   Entero sin signo /   Entero hexadecimal (con a, b, c, d, e, f)
X /   Entero sin signo/    Entero hexadecimal (con A, B, C, D, E, F)
f /   Coma flotante /   Valor con signo: [-]dddd.dddd
e /   Coma flotante /   Valor con signo: [-]d.dddd...e[+/-]ddd
g /   Coma flotante /   Valor con signo, dependiendo del valor de la precisión. Se rellenará con ceros y se añadirá el punto decimal si es necesario.
E /   Coma flotante /   Valor con signo: [-]d.dddd...E[+/-]ddd
G /   Coma flotante /   Como en g, pero se usa E para los exponentes.
Caracteres         
c /   Carácter /   Un carácter.
s /   Puntero a cadena /   Caracteres hasta que se encuentre un nulo o se alcance la precisión especificada.
Especial         
% /   Nada /   El carácter '%'
Punteros         
n /   Puntero a int /   Almacena la cuenta de los caracteres escritos.
p /   Puntero /   Imprime el argumento de entrada en formato de puntero: XXXX:YYYY ó YYYY

Veamos ejemplos:

Código [Seleccionar] Expandir

#inlcude <stdio.h>

int main (void) {
int entero = 10;
float real = 2.4313;
char caracter = 'F';

/*Vames el valor de "entero*/
printf ("%d", entero);

/*El de "float"*/
printf ("\n %f", float);

/*El de "caracter"*/
printf ("\n %c", caracter);

/*Verlo todo junto...*/
printf ("\n %d, %f, %c", entero, float, caracter);

/*El cuadrado de entero*/
printf ("\n %d", entero*entero);

/*Entero en octal*/
printf ("\n %o", entero);

/*El carçacter que representa entero en el código ASCII*/
printf ("\n %c", entero);

getchar();
}

Como pueden ver, podemos mostrar un mismo número en distintos formatos de una forma muy simple.

5.4.2- Entrada de datos formateada (scanf)

La función scanf nos permite almacenar datos de un formato especificado en una variable, lo usual es usarla de este modo:

scanf ("comando", &variable);

Camando ya sabemos lo que es (%d, %C, %o...), y variable es el identificador de la variable que contendrá los datos. Le agregamos al principio &, porque lo que usamos con esta función no es la variable en sí, sino que su dirección de memoria, pero esto lo veremos mejor con los punteros.

Bien, y esto es tna fácil como lo muestra este claro ejemplo:

Código [Seleccionar] Expandir

#include <stdio.h>

int main (void) {
int numero;
char letra;

printf ("Escriba un número: ");
scanf ("%d", &numero);

printf ("Escriba una letra: ");
scanf ("%c", &letra);

printf ("Este es el número %d, y esta la letra %c", numero, letra);
getchar();
}

¿Vieron qué fácil?

5.5 Ejercicios

1- Has un programa que le pida dos números al usuario, y le muestre su suma, su división y el resto de la división.

2- Has un programa que le pida una letra al usuario y le diga a éste entre qué otras dos se encuentra.

El reto

Has un programa que le pida un número al usuario, para luego mostrarlo en octal, hexadecimal, su representación en el códgio ASCII, su cuadrado y su doble.

Hasta la próxima, me voy que ya me duele la espalda, de tanto estar sentado.