Introducción al lenguaje de programación C

La manera habitual de aprender a programar en cualquier Lenguaje de Programación, a los

que el C o C++ , no están exentos, es la de formular una Metodología de Trabajo , que permita
efectuar el Análisis del Problema dado , Elaborar Algoritmos con Diagramas de Flujos y/o
Seudocódigo y por último Codificar el Algoritmo para su prueba y validación en una
Computadora.

La Codificación es el pasaje de toda la lógica desarrollada en los respectivos algoritmos a un

Lenguaje de Programación reconocido por el Computador y por el Programador. Para esto es
indispensable conocer las Reglas de Escritura o Sintaxis (como se escriben las instrucciones de
un programa) de un Lenguaje de Programación que servirán para todas las aplicaciones y
desarrollos, desde programas simples a programas de cualquier grado de complejidad.

El Lenguaje de Programación C, entonces, se convierte en un medio de comunicación común

entre el usuario programador y la Computadora a los fines que la misma haga lo que el usuario
necesita en relación con la solución de un problema planteado. Conocidas las Estructuras
Básicas como las Instrucciones Secuenciales, Selectivas o Condicionales y las Repetitivas así
como los conceptos de Acumulador, Contador, Asignación y Bandera o Palabra Clave,
corresponde por una cuestión de practicidad analizar los problemas resueltos con Diagrama de
Flujo y Seudocódigo desde el punto de vista de la Lógica a la que deben responder, y
traducirlos o pasarlos al Lenguaje C para que la Computadora efectúe el procesamiento según
las instrucciones que forman parte de un programa y presente los resultados de acuerdo a lo
requerido en cada caso particular.

El primer ejemplo básico es el siguiente:

- Realizar un programa en C que imprima por pantalla la leyenda “PRIMER PROGRAMA EN C “.

Programa 1

# include <stdio.h>
main ()
{ /* Primer Programa escrito en C */
printf ("PRIMER PROGRAMA EN C \n");
return 0;
}

La forma general de un programa en C es la siguiente:

# include <NOMBRE DEL FICHERO> (cantidad de INCLUDE según la necesidad del programa)
main ( ) {
Cuerpo del programa o programa con las instrucciones a ejecutar. Siempre está entre dos
llaves que significan Inicio y Fin de Ejecución del Programa respectivamente.
}

El significado de cada parte es el siguiente:

# include < stdio.h>  # include

Corresponde al Preprocesador del C++ y consiste en un procesador de Texto que realiza
inclusión de Ficheros llamados Archivos de Cabecera (Header), de ahí la extensión .h .

Con esta directiva se ponen a nuestra disposición las funciones existentes en el Archivo de
Cabecera identificado en el ejemplo con el nombre stdio.h.

# include es una directiva de inclusión de un archivo de cabecera (header) ú orden de leer un

Archivo de Texto especificado en el nombre que sigue a la misma. , en este caso, y reemplazar
esta línea por el contenido de dicho archivo en la medida que se necesita durante la ejecución
del programa. El ejemplo tiene la función printf, la cual es posible utilizar porque previamente
se ha incluido dentro del programa el contenido del Archivo de Cabecera de entrada-salida
(input – output) < stdio.h >.

De idéntica manera se procede con cualquier otra función estándar de biblioteca o funciones
creadas por el usuario e incorporadas al archivo de cabecera que corresponda según el tema.

Algunos ejemplos de Archivos de Cabecera son:

stdio.h. Incluye los prototipos de las funciones estándar de Input - Output (de ahí su nombre
std de estándar Input Output) como scanf, printf, etc.

conio.h. Incluye las funciones clrscr ( ), getch ( ), etc.

math.h. Incluye las funciones de matemáticas sqrt( ), sin( ), tan( ), etc.

Existen otros archivos de cabecera como ctype.h, graphics.h, etc., que se utilizarán
progresivamente. La totalidad de dichos archivos se encuentran disponibles en el Manual de
C++ y en la ayuda Help, de manera que se pueden consultar las funciones disponibles por cada
versión o fabricante de C++.

La directiva # include tiene algunas características importantes:

- No es una sentencia de programa sino una orden que se copie literalmente un archivo de
texto ubicado en el directorio INCLUDE, en el lugar en que ella está ubicada, razón por la que
no es necesario terminarla con ; como es exigible por el C para sus instrucciones.

- Cuando se pone < > se realiza la búsqueda en el directorio estándar donde se encuentra el
fichero INCLUDE .Caso contrario si se pone “stdio.h”, por ejemplo ,el compilador lo buscará en
el directorio activo en el momento de compilar.

- La existencia de estos archivos es evitar la repetición de la escritura de largas definiciones en

cada programa.

main ( ) o Función Principal Indica donde comienza el programa, cuyo núcleo es un conjunto
de sentencias que están delimitadas o encerradas por llaves { } llamada “ Cuerpo Principal del
Programa “.
Entre estas dos llaves, {  llave abierta significa Inicio de Ejecución del Programa, y }  llave
cerrada Fin de Ejecución del Programa , se encuentran todas las instrucciones necesarias para
solucionar un problema planteado.

Para el caso del ejemplo main ( ) es la encargada de llamar a la función de biblioteca printf ( ) y
en general es la que posibilita la ejecución y compilación del programa. Su ausencia da un
inmediato mensaje de error evitando la compilación y ejecución del programa, por lo tanto
impide continuar trabajando con el programa hasta tanto se la coloque.

main ( ) puede llamar a dos clases de funciones : las funciones propias o creadas por el usuario
y las funciones residentes en la Biblioteca estándar escritas para el C por el fabricante de
Software.

Ejecutada la instrucción printf (“.......\n”); la finalización con ; indica al compilador el fin de la

misma. El símbolo \n indica que después de imprimir el mensaje se pase a la línea siguiente o
se transfiera el control de la ejecución del programa a la línea siguiente. La segunda sentencia
del ejemplo es return 0; termina el programa y devuelve un Valor 0 (cero) al argumento de
main ( ) para indicar a quién la invoca, main ( ), que ha finalizado la ejecución del programa.

Comentarios Las inclusiones de comentarios son útiles para aclarar lo que realiza el programa
o partes de él. No son Ejecutables y No Intervienen en la lógica de actuación del programa por
lo que no influyen en el funcionamiento del mismo. Se los indica de la forma / * ....*/ y para el
caso del ejemplo es : /* Primer Programa escrito en C */

Programa 2

# include <stdio.h>
main()
{ /* Segundo Programa escrito en C */
printf("Buenas\n"); --------- > Probar con las opciones: \+ para tabular
printf("Noches\n"); \” comillas
printf("\n"); \\ diagonal invertida
return 0; \b retroceso
}

2.- Tipos de Datos

En el Lenguaje de Programación C existen distintos tipos de datos cada uno de los cuales se
pueden representar en forma diferente en la memoria del computador. En los Tipos de Datos
Básicos el requerimiento de memoria determina el Rango de Valores que se permiten para
cada tipo, lo cual varía de un compilador de C a otro o con las versiones del C. Una clasificación
general de Datos es la siguiente:
Datos numéricos

Enteros

Reales y exponenciales

No numéricos

Lógicos: TRUE o FALSE

Carácter: Alfabéticos, numéricos y especiales

Cadena de caracteres

3.- Identificadores

Los identificadores son nombres que se dan a diversos elementos que intervienen en un
programa como constantes, variables, funciones y arrays (arreglos). Están formados por letras
y dígitos, en cualquier orden excepto el primer carácter que debe ser una letra. Se pueden
utilizar mayúsculas y minúsculas no acentuadas para la mayoría de los compiladores,
recordando que en Informática una letra mayúscula no es lo mismo que una minúscula. La
longitud de los identificadores no está limitada, pero el compilador acepta los primeros 31
caracteres. Es costumbre utilizar minúsculas para la mayoría de los identificadores a excepción
de Constantes Simbólicas que son mayúsculas.

4.- Palabras Claves

Son palabras reservadas que tienen un significado preestablecido en C y en cualquier lenguaje

de programación, debido a lo cual no se pueden utilizar como Identificadores dentro de un
programa. Ejemplo: break, case, char, default, double, if, else, while, continue, do, float, for,
goto, int, long, register, static, struct, etc.

5.- Constantes

Se designa con este nombre a un " Valor " numérico o string (alfa numérico) cualquiera y son
iguales a los datos ya definidos. Se caracterizan porque no cambian durante la ejecución del
programa.

Ejemplo: para el cálculo del área de un círculo s = PI x r^2, el valor de PI = 3,14159 es fijo e
inalterable cualquiera sea el valor del radio r. En C se pueden colocar los valores directamente
o representarlos mediante identificadores que son nombres que se asignan a cada constante.
Para este último caso estamos en presencia de constantes simbólicas. Una constante simbólica
es una cadena de caracteres especiales y el nombre se escribe con mayúsculas. La sintaxis de
una constante simbólica es:

# define NOMBRE Valor

Ejemplo # define PI 3.14159

7.- Operadores

Son signos especiales que indican determinadas operaciones a realizar con las variables y
constantes. Los operadores pueden ser de tipo aritméticos, lógicos, relacionales, de
incremento y decremento, asignación, como se indica en las Tablas siguientes.

8.- Variables

Del ejemplo anterior, Punto 5, surge que PI es constante y el radio r puede tener diferentes
valores. A elementos con las características del radio r se conoce como variable. Una Variable
es un objeto o dato cuyos valores pueden cambiar durante la ejecución de un programa. Las
variables pueden ser numéricas, lógicas y alfanuméricas. Para el caso del ejemplo "Calcular el
área de un círculo" la variable es r, es del tipo numérica y puede tener distintos valores.

Área  s = PI x r^2 = 3,14159 x r x r Un programa en C que calcula el área de un círculo para

un determinado valor de r se muestra a continuación:

Programa 3

# include <stdio.h> /* programa que calcula el área de un círculo */

# include <conio.h> /* biblioteca que permte usar getch() */
main()
{
float r,area; /* se declaran como float a las variables r y área */
printf ("Introducir valor de radio =\n");
scanf ( "%f" ,&r); /* ingreso de valores de r con punto decimal por teclado */
area = 3.14159 * r * r ;
printf ("Area = %f \n",area);
printf ( "Fin del programa");
getch ();
return 0 ;
}

Este programa simple se puede generalizar para varios valores de r y es donde se nota la
potencialidad o ventaja de realizar este cálculo en C. Como nuevo problema se puede
considerar " calcular el área de un círculo para 100 radios distintos". Como existe una
multiplicación de un valor fijo o constante como es PI se puede poner de la forma Indicada
como Constante Simbólica y el programa sería:

Programa 4

# include < stdio.h > /* programa que calcula el área de un círculo */

# include < conio.h >
# define PI 3.14159
main(){
float r , area;
printf ( "Introducir valor de radio =\n");
scanf ( "%f",&r); /* ingreso de valores de r con punto decimal por teclado */
area = PI * r * r ; /* cambio de 3.14159 por PI */
printf ("Area = %f \n ",area);
 printf ("Fin del programa ");
getch();
return 0;
}

Recordar que se deben declarar todas las variables antes que aparezcan sentencias
ejecutables que hagan uso de ellas.

9.- Expresiones

Es un Símbolo o grupos de Símbolos que un Lenguaje de Programación puede evaluar, y

pueden ser combinaciones de constantes, variables, funciones, arrays, símbolos de
operaciones, paréntesis, clasificados de la forma siguiente:

10.- Tablas de Variables, Constantes y Operadores

En cuanto a los tipos de variables, los más habituales en C los expondremos a continuación.

Tabla 1. Tipos de variables

TIPO EQUIVALENCIA
SE MEMORIA RANGO
DE EN OBSERVACIONES
ESCRIBE REQUERIDA* ORIENTATIVO*
DATOS PSEUDOCÓDIGO

Uso en contadores,
Entero int 2 bytes - 32768 a 32767 Entero control de bucles
etc.

Igual que int pero

Entero - 2147483648 a
long 4 bytes Entero admite un rango
largo 2147483647
más amplio

Hasta 6 decimales.
Decimal - 3,4·1038 a
float 4 bytes Real También admite
simple 3,4·1038
enteros

Hasta 14 decimales.
Decimal - 1,79·10308 a
double 8 bytes Real También admite
doble 1,79·10308
enteros

Carácter,
Carácter char 1 bytes 0 a 255 Alfanumérica independiente o
parte de una cadena
Operadores aritméticos
Existen dos tipos de operadores aritméticos:

DdF C Descripción

+ + Suma, adición

- - Resta, sustracción

. * Multiplicación, producto

Div / Cociente división entera

Mod % Resto división entera

/ / División

Operador de asignación

DdF C Descripción

← = Asignación

Ejemplo

Programa 5

/* uso de los operadores aritméticos */

#include <stdio.h>
main() /* realiza varias operaciones */
{
int a=1,b=2,c=3,r;
r=a+b;
printf("%d + %d = %d\n",a,b,r);
r=c-a;
printf("%d - %d = %d\n",c,a,r);
b++;
printf("b + 1 = %d",b);
}
Operadores relacionales

DdF C Descripción

> > Mayor

≥ >= Mayor o igual

< < Menor

≤ <= Menor o igual

= == Igual

≠ != Diferente

Operadores lógicos

DdF C Descripción

^ && And, y, conjunción

∨ || Or, o, disyunción

¬ ! Not, no, negación

Operadores lógicos

Los operandos son considerados falsos (valor 0) ó ciertos (valor distinto de 0). El resultado
siempre es 0 ó 1.

DdF C Descripción

^ && And, y, conjunción

∨ || Or, o, disyunción

¬ ! Not, no, negación

VALORES DE LOS CODIGOS DE CONTROL DE FORMATO EN C

El indicador de tipo de dato (código de formato o cadena de control) hace explícito el tipo de
dato que se espera recibir en la entrada. Se usan los mismos códigos para mostrar datos en
pantalla con printf. Los indicadores de tipos principales son los siguientes:

Código de formato Significado

%d Tipo entero (int)

%ld Tipo entero largo (long)

%lf Tipo decimal doble precisión (double)

%c Tipo carácter

%s Tipo cadena alfanumérica (array de caracteres)

Control de flujo

En C las sentencias se ejecutan sucesivamente una tras otra. Esto define un camino o dirección
según la cual se va desarrollado el programa. Sin embargo, habrá momentos en que el
programa deba ejecutar determinadas partes dependiendo del estado en el que se halle el
programa o de las variables externas. Esto permitir modificar el orden de la ejecución para
adaptarse al estado del programa y bifurcar hacia nuevas subrutinas cuando se cumplan
ciertas condiciones, que el programador fijar de antemano. Los mecanismos en C que
permiten llevar esto a cabo son:

 la sentencia if
 el bucle while
 el bucle do - while
 el bucle for
 las sentencias break y continue
 la selección múltiple switch

La sentencia if

La primera sentencia de control es la sentencia if. Admite dos tipos de sintaxis:

if (expresión)
sentencia1;

o también:
if (expresión)
sentencia1;
else
sentencia2;

Esta sentencia es equivalente a la que poseen la mayoría de lenguajes de programación y sirve

para bifurcar en un punto de programa. Permite tomar decisiones al programa. En su primera
forma, la sentencia1 sólo se ejecuta si el resultado de evaluar la expresión es verdadero
(distinto de cero). En la segunda forma, tenemos dos posibilidades: si al evaluar la expresión el
resultado es verdadero se ejecuta la sentencia1, pero si el resultado es falso se ejecuta
la sentencia2. En cualquier caso sólo una de las dos sentencias se ejecuta. Por ejemplo:

if (numero1 == 1)
printf("la variable numero1 vale 1");
else
printf("la variable numero1 no vale 1");
Tras evaluarse la expresión if y ejecutarse la sentencia adecuada, el programa continúa con la
línea siguiente a la de la última sentencia del if. Para la sentencia if vale como expresión
cualquiera válida en C, incluso las asignaciones y llamadas a funciones. El caso en que la
expresión es una asignación suele ser sorprendente, ya que en la mayoría de los lenguajes este
tipo de expresiones no es válido. Como sentencia vale cualquier tipo de sentencia válida en C,
entre ellas la propia sentencia if. En este caso hablaremos de sentencias if anidadas. Por
ejemplo:
if (num > 0)
if (num == 1)
printf("num es igual a 1");
else
printf("num es mayor que 1);
else
printf("num es menor que 1");

Cuando hay dos if anidados y a continuación hay un else, éste pertenece al último if. Así en el
caso anterior el primer else corresponde al segundo if. Si queremos que un else pertenezca al
primer if de un if anidado deberemos encerrar al segundo entre llaves. Por ejemplo:

if (num > 0)
{
if (num == 1)
printf("num es igual a 1");
}
else
printf("num es menor que 0");

Cuando necesitamos ejecutar varias sentencias que dependen de un if, utilizaremos la

sentencia de tipo bloque de sentencias. Un bloque de sentencias es un grupo de sentencias
encerradas entre llaves { y }. Por ejemplo:

if (num >= 0) {
printf("num %d\n");
if (num == 0)
puts("num 0");
if (num >= 1)
puts("num mayor o igual a 1");
}

El bucle while

Un bucle es un conjunto de sentencias que se ejecutan repetidamente hasta que se alcanza

una condición de fin de bucle, o condición de salida. El bucle while es el tipo de bucle más
sencillo. En su modo más simple se escribe:

while (expresión)
sentencia;

El bucle while comienza por evaluar la expresión. Si es cierta, se ejecuta la sentencia. Entonces
se vuelve a evaluar la expresión. De nuevo, si es verdadera, se vuelve a ejecutar la sentencia.
Este proceso continúa hasta que el resultado de evaluar la expresión es falso. Por esto se le
llama a esta expresión la condición de salida o corte de control. Por ejemplo:

int variable = 10;

while (variable)
printf("la variable vale %d\n", variable--);

En este caso se imprime el valor de la variable hasta que se llega a 1. Normalmente, en las
sentencias del bucle while se coloca alguna instrucción que modifique la expresión de control.
Lo más habitual es utilizar un bloque de sentencias en vez de una sentencia única. Por ejemplo:

int variable = 10;

while (variable) {
printf("valor de la variable %d\n", variable);
variable--;
printf("valor tras decrementar la variable %d\n", variable);
}

El bucle do-while

La sintaxis de este bucle es:

do
sentencia;
while (expresión);

Su funcionamiento es análogo el del bucle while, salvo que la expresión de control se evalúa al
final del bucle. Esto nos garantiza que el bucle do-while se ejecuta al menos una vez. Es menos
habitual que el bucle while.

Podemos incluir dentro del bucle un grupo de sentencias, en vez de sólo la sentencia. Por
ejemplo:

/* Uso de los operadores aritméticos */

#include <stdio.h>
main() /* Realiza varias operaciones */
{
int c = 9;
do {
printf("número actual %d\n", c);
c=c-1;;
} while (c >= 0);
}

El bucle for

La sintaxis del bucle for es:

for (inicio, control, incremento)

sentencia;

Este bucle se utiliza para realizar una acción un número determinado de veces. Está
compuesto de tres expresiones: la de inicio, la de control y la de incremento, y de una
sentencia. Su versión más sencilla es:

for (i =0; i < 10; i++)

printf("i vale %d\n", i);

Esta versión del bucle imprime un mensaje en la pantalla mientras que no se alcance la
condición de salida, i == 10.

El funcionamiento del bucle for es el siguiente:

 primero se ejecuta la expresión de inicio. Normalmente‚ esta es una expresión de

asignación a una variable, que le da un valor inicial.
 Luego se comprueba la expresión de control. Si esta expresión es verdadera se ejecuta
la sentencia, o el grupo de sentencias. Si la expresión es falsa el bucle finaliza.
 Tras ejecutarse la sentencia se evalúa la expresión de incremento. Habitualmente lo
que hace esta expresión es incrementar la variable de control.
 A continuación se vuelve al segundo paso. El bucle finaliza cuando la expresión de
control es falsa.

En un bucle for podemos omitir la expresión de inicio; por ejemplo, si sabemos que la variable
ya está inicializada:

int i = 0;
for ( ; i < 10; ++i)
printf("i vale %d\n", i);

También podemos omitir la expresión de incremento. Esto es habitual cuando la variable de

control ya se modifica dentro del bucle. Por ejemplo:

int i = 0;
for ( ; i < 10; )
printf("i vale %d\n", i++);

El bucle for es equivalente a un bucle while escrito del siguiente modo:

inicio;
while (control) {
sentencia;
incremento;
}

Este bucle while puede servirnos para salir fácilmente de dudas al escribir un bucle for, ya que
se ve claramente el orden de ejecución de las expresiones y sentencias dentro del bucle for.
Como se ve, en cada pasada del bucle for se sigue el orden: evaluación de control, ejecución
de sentencia y evaluación de incremento.

Las sentencias break y continue

Hay veces en que interesa romper un bucle en una determinada posición, para ejecutar una
nueva pasada del bucle o para finalizar su ejecución. Esto suele ser habitual cuando el bucle
tiene una gran complicación o cuando necesitamos salir "por las malas" de él. Esto último
suele ser frecuente cuando en el bucle se producen "condiciones de error". Para realizar estos
dos tipos de salto disponemos de dos sentencias: break y continue.
La sentencia break rompe la ejecución de un bucle o bloque de instrucciones y continúa en la
instrucción que sigue al bucle o bloque. Por ejemplo:

int a = 10;
while (1) {
if (a-- <= 1) break;
printf("%d\n", a);
}

Aunque en apariencia este es un bucle sin fin, ya que la condición while(1) siempre es cierta,
este bucle se acaba cuando la variable a valga 1. El bucle simplemente decrementa la variable
e imprime su valor.
La sentencia continue rompe la ejecución habitual del bucle y procede a evaluar de nuevo la
expresión del bucle. Actúa como si se saltase al final del bloque de un bucle. Por ejemplo:

int a = 0;
while (a < 10) {
a++;
if (a == 7) continue;
printf("%d\n", a);
}
Este código muestra los números del 1 al 10 excluyendo el 7.

La sentencia de selección múltiple switch

Esta sentencia sirve para agrupar varias sentencias if en una sola, en el caso particular en el
que una variable es comparada a diferentes valores, todos ellos constantes, y que realiza
acciones si coincide con ellos. Su sintaxis es:

switch (control) {
case expresión1_const:
sentencia1;
break;
case expresión2_const:
sentencia2;
break;
default:
sentencia0;
break;
}

Su sintaxis es más complicada que la de anteriores bucles, ya que agrupa un mayor número de
acciones y posibilidades en una sola sentencia. El modo de funcionamiento es el siguiente:
 primero se evalúa la expresión de control.
 A continuación se compara con la expresión de la primera etiqueta case. Si son iguales,
se ejecuta la sentencia1.
 Luego se vuelve a comparar la expresión de control con la etiqueta del segundo case.
De nuevo, si son iguales, se ejecuta la sentencia2.
 Se repite el proceso hasta agotar todas las etiquetas case. Si al llegar a la
etiqueta default no se ha ejecutado ninguna otra sentencia ésta es la acción por
defecto. La etiqueta default es opcional. Si no la ponemos el programa simplemente
salta a la línea siguiente.

Hay que tener cuidado con un aspecto de este bucle. Cuando una expresión de una
etiqueta case es igual a la sentencia de control, se ejecutan todas las sentencias que sigan
hasta que se alcance una nueva etiqueta case, y luego se vuelve a comparar la expresión de
control. Este mecanismo tiene una ventaja y un inconveniente. La ventaja es que no
necesitamos encerrar entre llaves el grupo de sentencias a ejecutar para cada etiqueta. El
inconveniente es que al agotar las sentencias de una determinada etiqueta la
sentencia switch prosigue con la siguiente etiqueta case. Habitualmente lo que se pretende es
que tras ejecutar el grupo de sentencias se finalice el switch. Para evitar el que se ejecuten
más sentencias, habitualmente se acaba cada grupo de sentencias con una sentencia break. La
sentencia break pasa entonces la ejecución a la siguiente línea de programa que prosiga al
bucle switch.

También se permite poner etiquetas múltiples para un mismo grupo de sentencias. Si dejamos
una etiqueta case sin sentencias a ejecutar entonces se asocia a la siguiente etiqueta. Esto es
útil para ejecutar una misma acción para distintos valores de la expresión.
Vamos a ver un ejemplo de múltiples casos con if-else y luego con switch:
#include <stdio.h>
main()
{
int num;
printf( "Introduce un número " );
scanf( "%i", &num );
if ( num == 1 )
printf ( "Es un 1\n" );
else if ( num == 2 )
printf ( "Es un 2\n" );
else if ( num == 3 )
printf ( "Es un 3\n" );
else
printf ( "No es ni 1, ni 2, ni 3\n" );
}

Ahora con switch:

#include <stdio.h>
main()
{
int num;
printf( "Introduce un número " );
scanf( "%i", &num );
switch( num ) {
case 1:
printf( "Es un 1\n" );
break;
case 2:
printf( "Es un 2\n" );
break;
case 3:
printf( "Es un 3\n" );
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}

Como vemos, el código con switch es más cómodo de leer.

Vamos a ver qué pasa si nos olvidamos algún break:

#include <stdio.h>
main()
{
int num;
printf( "Introduce un número " );
scanf( "%i", &num );
switch( num ) {
case 1:
printf( "Es un 1\n" );
/* Nos olvidamos el break que debería haber aquí */
case 2:
printf( "Es un 2\n" );
break;
default:
printf( "No es ni 1, ni 2, ni 3\n" );
}
}

Si al ejecutar el programa escribimos un 2 tenemos el mensaje Es un dos. Todo correcto. Pero

si escribimos un 1 lo que obtenemos en pantalla es:

Es un 1
Es un 2

¿Por qué?. Pues porque cada caso empieza con un case y acaba donde hay un break. Si no
ponemos break aunque haya un case el programa sigue hacia adelante. Por eso se ejecuta el
código del case 1 y del case 2.