C4: Instrucciones del lenguaje.

Las instrucciones en un lenguaje de programación proporcionan la posibilidad de representar las

acciones básicas que se requieren para resolver computacionalmente un problema. Se describen las
principales instrucciones del lenguaje C++.
3.1 Instrucción nula
Sintácticamente corresponde a la ausencia de instrucción, que puede denotarse por un ; (punto y
coma), semánticamente no tiene ningún efecto. Resulta útil cuando una instrucción es necesitada
sintácticamente, pero sin acción semántica.
Es decir, suele usarse cuando se desea indicar explícitamente que no se desea ejecutar nada, lo que
es útil para facilitar la legibilidad del código o, como veremos más adelante en el tema, porque otras
instrucciones la necesitan para indicar cuándo en algunos de sus bloques de instrucciones no se ha
de realizar ninguna acción.
3.2 Instrucción compuesta
Un bloque o instrucción compuesta es una secuencia de instrucciones entre llaves { } que puede
estar precedida de declaraciones y/o definiciones. Cada instrucción o declaración se separa una de
otra por punto y coma ;.
Ejemplo 3.1
{ double Lado1, Lado2, Lado3, SemiP, Area;
clrscr(); // para limpiar la pantalla
cout <<"Escriba la longitud de cada lado, separada por espacio:";
cin >> Lado1, Lado2, Lado3;
.............................................
}

En este ejemplo aparecen definiciones e instrucciones en la instrucción compuesta. Es el caso que

propiamente es llamado como bloque en los lenguajes de programación.

Ejemplo 3.2
{ SemiP = (Lado1+Lado2+lado3) / 2;
Area = sqrt(SemiP*(SemiP-Lado1)*(SemiP-Lado2)*(SemiP-Lado3));
cout << "El área del triángulo es: " << Area;
}
En esta instrucción compuesta sólo aparecen instrucciones. De esta forma, muchas veces es llamada
secuencia de instrucciones.
Para los bloques se definen reglas que determinar donde los objetos de datos que se declaran pueden
ser empleados, lo que esta relacionado con los conceptos de alcance y tiempo de vida.
3.2.1 Nociones elementales de alcance.
Alcance, o ámbito de un identificador es el segmento del texto del programa en el que el
identificador es visible, tiene un determinado significado y el objeto de dato, por ejemplo, una
variable, nombrado por él puede ser referenciado por su nombre en esas instrucciones.
Los lenguajes de programación definen reglas de alcance para los identificadores de los objetos de
datos declarados en un bloque, basados en los siguientes conceptos:
• Un objeto de dato es local a un bloque donde él esté declarado. Dicho objeto tendrá validez
en todo el bloque, desde el punto del programa donde se declaran, a menos que no sean
redefinidas en bloques interiores.
• Un objeto de dato es libre en el bloque si no está declarado en él.
Observemos el siguiente programa:
// Muestra general de alcance
int x;
void main()
{ int a, b, h; // B1
.........
{ int b, x, y; // B2
.........
}
.........
{ int x; // B3
char c, d;
...........
}
.........
}

• a, b y h son locales al bloque B1;

• b, x, y son locales a B2,
• a, h ocurren libres en B2.
• Hay una definición de una variable de nombre x que tiene validez en todo el fichero de
programa a partir de su definición, ya que es definida fuera de cualquier función. Esa
definición de x es global para el fichero de programa completo.

Note que:
 En el alcance de B2 se considera la ocurrencia de variable de nombre b como local, aun
cuando existe una referencia libre.
 Dentro del alcance del propio B2 y dentro del alcance de B3 se considera la ocurrencia de
variable de nombre x como local, aun cuando existe una referencia global.

El C++ es un lenguaje que se rige por reglas de alcance estático, para las cuales un identificador
libre puede tener las siguientes interpretaciones:

1. Se considera indefinido fuera del bloque donde esté declarado y por tanto su uso no es
permitido. Ese es el caso de las variables x e y respecto al bloque B3.
2. Se considera no local al bloque. En este caso el identificador usado en el bloque está declarado
en otro que lo contiene. Ese es el caso de a, b, h respecto al bloque B3.
3. Se considera global, en el caso que el identificador tiene validez para todo el programa, a partir
del punto de declaración, porque está definido fuera de todos los bloques del programa. Ese es el
caso de la variable x.
Note que todas estas determinaciones el compilador puede realizarlas desde tiempo de compilación,
a partir del texto del programa fuente ( de ahí que sean reglas de alcance estático ).
El lenguaje contempla cuatro formas de alcance, que se derivan de la explicación dada arriba:
• Alcance de bloque: identificadores declarados dentro de un bloque, tal y como se definió
arriba.
• Alcance de archivo: identificadores declarados en el nivel más externo del fichero, fuera de
todos los bloques del programa y que por tanto son visibles a todo el código que le sigue. Es el
caso de los identificadores globales.
C++ dispone del operador (::), llamado operador de resolución de visibilidad. Este operador,
antepuesto al nombre de una variable global que está oculta por una variable local del mismo
nombre, permite acceder al valor de la variable global. Por ejemplo, si queremos tener acceso a
la variable x global dentro del bloque B2 o dentro del bloque B3, tenemos que escribir ::x
donde quiera vaya a ser usada. El operador (::) no puede utilizarse para ver una variable local
oculta por otra variable local del mismo nombre.
• Alcance de función: identificadores declarados dentro del cuerpo de la función y los
parámetros formales. Se estudia con mayor detenimiento en la conferencia sobre funciones.
• Alcance de clase: componentes de la clase. Se estudia con mayor detenimiento en el tema
Programación Oriento a Objeto.
3.2.2 Determinación de asignación de memoria a las variables (Para el seminario)
Cuando se crean variables, se tiene un número de opciones para especificar la duración o tiempo de
vida de las mismas. En particular, existen en C++ varias formas de almacenamiento para las
variables, de la cual estudiamos ahora las formas de tiempo de vida local. El tiempo de vida de una
variable es el intervalo de tiempo de ejecución en que la variable existe, o sea, tiene asignado un
espacio de memoria donde está almacenado un valor. En C++ el tiempo de vida está ligado, en
algunos casos, a las diferentes formas de almacenamiento para las variables que él posee, que son
las clases de almacenamiento:
• automático (auto) Clase de almacenamiento automático
• registro (register)
• estático (static) Clase de almacenamiento estático
• externo (external)
La clase de una variable puede ser declarada con su definición, por ejemplo:
static double a, b ;
auto
Las variables locales que se declaran dentro del alcance de un bloque son locales a ese bloque. A
menudo se les denomina variables automáticas, ya que automáticamente se les asigna memoria en
el punto de su definición y se les retira al terminar el bloque de su definición (cuando aparece la
llave de cierre del bloque). Este método permite que, aunque se haya definido un gran número de
variables en un programa, estas no ocupen memoria simultáneamente en el tiempo, y solo vayan
incrementando la memoria cuando se las necesita, para luego, una vez usadas desaparecer, dejando
a la memoria en su estado original. En C++ se puede usar la palabra reservada auto para tal
declaración, sin embargo, como por omisión una variable local es auto no es necesario usar dicha
palabra clave.

No son inicializadas por defecto, y – antes de que el programa les asigne un valor – pueden
contener basura informática (conjuntos aleatorios de unos y ceros, consecuencia de un uso anterior
de esa zona de la memoria).
Las variables que han sido declaradas en el programa ejemplo son de tiempo de vida local. En el
caso de la variable que es global y tiene alcance de fichero recibe su memoria por una vez y la
mantiene durante toda la ejecución del programa.

register

Otra forma de almacenamiento local que brinda el lenguaje es la variable de clase register. La
palabra reservada register indica al compilador la búsqueda de formas de acceso rápidas para esa
variable, que en vez de ser mantenidas en posiciones de la memoria de la computadora, se guarden
en un registro de la máquina, aumentando la velocidad de ejecución del programa. Si no es posible
almacenarla en un registro se le da el tratamiento de automática. Es decir, lamentablemente, en este
caso no se puede imponer al compilador, este tipo de variable, ya que no tenemos control sobre los
registros libres en un momento dado del programa; la clase de almacenamiento register es
solamente una petición no una orden. Si el compilador no puede conceder la solicitud de
almacenamiento en registro la variable pasa a ser automática.

Hay que recalcar que esto es sólo válido para variables LOCALES, siendo imposible definir en un
registro a una global.
Hay limitaciones a la hora de usar las variables register:
• no se puede tomar o calcular la dirección de una variable register. Esta sólo puede
declararse dentro de un bloque,
Se puede utilizar una variable register como un argumento formal en una función, es decir, en la
lista de argumentos.
En instrumentaciones actuales del lenguaje el compilador elige automáticamente que variables
serán de clase register y no serán más mencionadas en este texto.

No existen los modos auto y register para las funciones.

static
Una variable estática (static) sólo es visible dentro del bloque donde está definida, pero a
diferencia de las automáticas su existencia (tiempo de vida) es permanente durante toda la ejecución
del programa. Esta clase de variable recibe su memoria y se inicializa una sola vez, cuando
comienza la ejecución del programa. Si no se inicializa explícitamente, el compilador lo hace
automáticamente a cero.
El modificador static se puede aplicar también a variables globales. Una variable global es por
defecto accesible desde cualquier fuente del programa. Si, por cualquier motivo, se desea que una
de estas variables no se visible desde otro fuente se le debe aplicar el modificador static.

Cuando ciertas variables son declaradas como static dentro de un bloque, estas variables conservan
su valor entre distintas ejecuciones de ese bloque. Dicho de otra forma, las variables static se
declaran dentro de un bloque como las auto, pero permanecen en memoria durante toda la ejecución
del programa como las extern. Cuando se llama varias veces sucesivas a una función (o se ejecuta
varias veces un bloque) que tiene declaradas variables static, los valores de dichas variables se
conservan entre dichas llamadas. La inicialización sólo se realiza la primera vez. Por defecto, son
inicializadas a cero.

Una función puede también ser definida como static, y entonces sólo es visible para las funciones
que están definidas después de dicha función y en el mismo fichero. Con estos modos se puede
controlar la visibilidad de una función, es decir, desde qué otras funciones puede ser llamada
extern
Una variable externa (extern) referencia a una variable definida con el mismo nombre a nivel
externo en cualquier parte del programa, aún cuando el programa se componga de varios ficheros
que deben ser enlazados juntos, dándole un carácter de globalidad a la declaración.

Las variables extern son variables globales, que se definen fuera de cualquier bloque o función, por
ejemplo antes de definir la función main(). Estas variables existen durante toda laejecución del
programa. Las variables extern son visibles por todas las funciones queestán entre la definición y el
fin del fichero. Para verlas desde otras funciones definidas anteriormente o desde otros ficheros,
deben ser declaradas en ellos como variables extern. Por defecto, son inicializadas a cero.

Una variable extern es definida o creada (una variable se crea en el momento en el que se le reserva
memoria y se le asigna un valor) una sola vez, pero puede ser declarada (es decir, reconocida para
poder ser utilizada) varias veces, con objeto de hacerla accesible desde diversas funciones o
ficheros. También estas variables pueden ocultarse mediante la declaración de otra variable con el
mismo nombre en el interior de un bloque.

Las variables definidas como static extern son visibles sólo para las funciones y bloques
comprendidos desde su definición hasta el fin del fichero. No son visibles desde otras funciones ni
aunque se declaren como extern. Ésta es una forma de restringir la visibilidad de las variables.

Por defecto, y por lo que respecta a su visibilidad, las funciones tienen modo extern.
Enfatizando:

Cuando una variable se define fuera de una función se dice que es externa. Las funciones en si
mismas son siempre externas, puesto que C++ no permite definir funciones dentro de otras
funciones.

Pues bien, puede darse el caso que una función escrita en un archivo dado, deba usar una variable
global definida en otro archivo. Bastará para poder hacerlo, que se la DECLARE especificando que
es EXTERNA a dicho módulo, lo que implica que está definida en otro lado.

Supongamos que nuestro programa está compuesto por sólo dos módulos: mod_prin.c y mod_sec.c
los cuales se compilarán y enlazarán juntos, creando un único ejecutable.

Si en el primer módulo (mod_prin.c) aparece una variable global, definida como

double var1 = 5;
El segundo módulo, ubicado en un archivo distinto de aquel, podrá referenciarla mediante la
declaración de la misma:
extern double var1 ;

Nótese que la inialización de la variable sólo puede realizarse en su DEFINICION y no en la

declaración.

Esta última, no reserva memoria para la variable sino que sólo hace mención que la misma ha sido
definida en otro lado.

Se puede omitir por completo el grupo de declaraciones extern si las definiciones originadas se
encuentran en el mismo archivo y antes de la función que las utiliza.

Es a veces útil y recomendable el agrupar las variables en un archivo único que luego pueda ser
incluido mediante el comando include.

Las variables externas son generalmente ubicadas después de los define y de los include.
Ojo: Los usos de variables estáticas y externas serán estudiados en detalles más adelante
(Funciones)
Retomando:

La visibilidad de una variable es la parte del programa en la que esa variable está definida y puede
ser utilizada. La duración hace referencia al tiempo que transcurre entre la creación de una variable
y el instante en que es destruida. En general la visibilidad de una variable auto abarca desde el
punto en el que se define hasta que finaliza el bloque en el que está definida. Si la declaración de
una variable no se encuentra dentro de ningún bloque (variable global o extern), la visibilidad se
extiende desde el punto de declaración hasta el final del fichero (otros ficheros pueden ver dicha
variable sólo si la declaran como extern).

En C++ la visibilidad de una variable puede ser local, a nivel de fichero o a nivel de clase. Este
último concepto, la clase, es la base de la Programación Orientada a Objetos que se estudiará más
adelante.

Las variables locales se crean dentro de un bloque sólo son visibles dentro del bloque en el que han
sido definidas y en sus bloques anidados, salvo que sean ocultadas por una nueva variable del
mismo nombre declarada en uno de esos bloques anidados.

Las variables que tienen visibilidad a nivel de fichero –variables globales– se definen fuera de
cualquier bloque, función o clase.

Una variable local declarada dentro de un bloque oculta una variable global del mismo nombre u
otra variable local también del mismo nombre declarada en un bloque más exterior. Esto no da
errores pero puede crear confusión al programar y al analizar el código. Por ejemplo, puede suceder
que en un bloque, hasta la declaración de una variable x se pueda estar utilizando otra variable con
el mismo nombre x de otro bloque que contenga al primero. A partir de su declaración y hasta el
final de su bloque, la nueva variable x será la local del bloque más interior.

Véase el ejemplo siguiente:

...
{
double x = 2.0;
cout << x; // se imprime 2.0
{
cout << x; // se imprime 2.0
double x = 3.0;
cout << x; // se imprime 3.0
}
cout << x; // se imprime 2.0
}
...

La duración (lifetime) de una variable es el período de tiempo en que esta variable existe durante la
ejecución del programa. La duración de una variable puede ser automatic (opción por defecto) o
static. En el primer caso –el caso de las variables declaradas dentro de un bloque – la variable se
crea y se destruye cada vez que se pasa por el bloque. Las variables static existen hasta que termina
la ejecución del programa. Su valor se conserva entre las distintas pasadas por un bloque. Para que
una variable local sea static hay que declararla como tal dentro del bloque.

Debe recordarse que aunque una variable exista durante toda la ejecución de un programa, sólo
puede utilizarse en la zona del programa en que esa variable es visible.

C++ dispone del operador (::), llamado operador de resolución de visibilidad (scope resolution
operator). Este operador, antepuesto al nombre de una variable global que está oculta por una
variable local del mismo nombre, permite acceder al valor de la variable global.

Considérese el siguiente ejemplo:

int a = 2; // declaración de una variable global a

void main(void)
{
...
cout << "a = " << a; // se escribe a = 2
int a = 10; // declaración de una variable local a
cout << "a = " << a; // se escribe a = 10
cout << "a = " << ::a; // se escribe a = 2
}

El operador (::) no permite acceder a una variable local definida en un bloque más exterior oculta
por otra variable local del mismo nombre. Este operador sólo permite acceder a una variable global
oculta por una variable local del mismo nombre.
3.2 Instrucciones condicionales

Hasta ahora los programas que hemos visto eran lineales. Comenzaban por la primera instrucción y
acababan por la última, ejecutándose todas una sola vez. . Lógico ¿no?. Pero resulta que muchas
veces no es esto lo que queremos que ocurra. Lo que nos suele interesar es que dependiendo de los
valores de los datos se ejecuten unas instrucciones y no otras.

Las instrucciones condicionales sirven para representar situaciones donde es necesario evaluar una
condición y tomar una decisión en dependencia de dicha evaluación.
Ejemplo 3.3: Un estudiante con estipendio puede obtener un aumento de un 25% del estipendio que
recibe si obtiene al final de curso un promedio de calificaciones mayor que 4. ¿Cuánto recibirá un
alumno que obtuvo un promedio dado al final del año académico?
Entradas: Estipendio y promedio.
Salida: Estipendio final
Algortimo: Note que ahora debemos determinar si su promedio es mayor que 4, lo que implicará
preguntar, o sea, probar una condición dentro del algoritmo:
leer estipendio y promedio
si promedio > 4 entonces incrementar el estipendio en un 25%:
estipendio = estipendio + 0.25*estipendio
imprimir el nuevo valor del estipendio
Entonces necesitamos representar la evaluación de condiciones y ejecución de alternativas en el
programa.
3.2.1 Alternativa
Tiene la forma general:

if ( condición )
instruccion
else instrucción_alternativa ;

La clausura else es optativa. La condición es una expresión cualquiera del lenguaje. Se evalúa la
condición. Si su valor es diferente de cero (o sea, verdadera) se ejecuta la instrucción , si su valor es
cero (por tanto falsa) se ejecuta la instrucción alternativa, en caso que exista clausura else, ya que
de no existir no se ejecutaría nada en ese caso.

Cuando el cuerpo del if está formado por una sola instrucción puede o no ir entre llaves, si existe
más de una instrucción entonces si lleva obligatoriamente las llaves ( {} ).
Ejemplo 3.4: Ejemplos de escritura de instrucciones condicionales.
a)
if ( i > 0 )
y = x / i ;

b)
if ( i > 0 && j > 0 )
k = j + i ;
else k = m;
El programa correspondiente al problema de entrada (ejemplo 3.3) sería:

#include <iostream.h>
#include <conio.h>
// aumento de estipendio
void main()
{ float estipendio, promedio ;
clrscr() ;
cout << "Cuál es el estipendio del alumno? " ;
cin >> estipendio ;
cout <<"Qué promedio académico obtuvo al final de curso? " ;
cin >> promedio ;
if (promedio > 4)
estipendio += 0.25*estipendio ;
cout <<"El nuevo estipendio es " <<estipendio <<'\n' ;
getch();
}

IF ... ELSE MÚLTIPLE

Esta sentencia permite realizar una ramificación múltiple, ejecutando una entre varias partes del
programa según se cumpla una entre n condiciones
Ejemplo 3.5: Leer los valores de los ángulos de un triángulo y clasificarlo de acuerdo a tales
valores.
Solución
Datos de entrada: valor de cada ángulo (supongamos que están dados en grados)
Resultados: Mensajes con la posible clasificación del triángulo.
Algoritmo de solución:
Leer las amplitudes de los ángulos.
Si pueden formar triángulo (porque la suma de los ángulos es 180) entonces determinar el tipo de
triángulo según las propiedades:
• Al menos un ángulo igual a 90: es rectángulo.
• Al menos un ángulo mayor que 90: es obtusángulo.
• En otro caso es acutángulo
Imprimir título de salida correspondiente
#include <iostream.h>
// Determinación si un triángulo es rectángulo, acutángulo u obtusángulo
void main()
{ double angulo1, angulo2, angulo3;
cout <<"Escriba la amplitud de cada ángulo, en grados y separados por espacios:
";
cin >>angulo1 >>angulo2 >>angulo3 ;
if ((angulo1+angulo2+angulo3)==180 && angulo1>0 && angulo2>0 && angulo3>0)
{ cout <<"Forman triángulo ";
if ( (angulo1==90) || (angulo2==90) || (angulo3==90) )
cout <<"rectángulo";
else
if ( (angulo1>90) || (angulo2>90) || (angulo3>90) )
cout <<"obtusángulo";
else
cout <<"acutángulo";
}
else
cout <<"Esos valores no corresponden a ángulos de un triángulo";
}

Se pueden poner if else múltiples o anidados como se deseen.

SENTENCIAS IF ANIDADAS

Una sentencia if puede incluir otros if dentro de la parte correspondiente a su sentencia. A estas
sentencias se les llama sentencias anidadas (una dentro de otra), por ejemplo,
if (a >= b)
if (b != 0.0)
c = a/b;

En ocasiones pueden aparecer dificultades de interpretación con sentencias if...else anidadas, como
en el caso siguiente:

if (a >= b)
if (b != 0.0)
c = a/b;
else
c = 0.0;

En principio se podría plantear la duda de a cuál de los dos if corresponde la parte else del
programa. Los espacios en blanco –las indentaciones de las líneas– parecen indicar que la sentencia
que sigue a else corresponde al segundo de los if, y así es en realidad, pues la regla es que el else
pertenece al if más cercano. Sin embargo, no se olvide que el compilador de C++ no considera los
espacios en blanco (aunque sea muy conveniente introducirlos para hacer más claro y legible el
programa), y que si se quisiera que el else perteneciera al primero de los if no bastaría cambiar los
espacios en blanco, sino que habría que utilizar llaves, en la forma:
if (a >= b)
{
if (b != 0.0)
c = a/b;
}
else
c = 0.0;

Recuérdese que todas las sentencias if e if...else, equivalen a una única sentencia por la posición que
ocupan en el programa.

3.3.2 Operador condicional (Mandar a Estudiar)

Da la posibilidad de obtener el valor de una expresión en dependencia del cumplimiento o no de

una condición. Su presentación general es

Operando1 ? Operando2 : Operando3

El tipo de Operando1 debe ser aritmético o puntero, en tanto los otros dos operandos pueden ser de
cualquier tipo.
El valor de este operador se calcula así: si el Operando1 es distinto de cero (verdadero) su valor
será el del Operando2, de lo contrario su valor será el del Operando3 .
Ejemplo 3.6
k = (i > 0 && j > 0) ? j + i : j - i ;
Si i tiene valor 5 y j tiene valor 2, entonces k toma valor 7, que corresponde a la suma de j+i.
La instrucción:
variable = Operando1 ? Operando2 : Operando3
es equivalente a:
if ( Operando1 )
variable = Operando2 ;
else variable = Operando3 ;
que se presenta bastante en la práctica.

Es decir, es una forma abreviada de expresar la sentencia if - else

3.3.3 Selección por casos

La sentencia que se va a describir a continuación desarrolla una función similar a la de la sentencia

if ... else con múltiples ramificaciones aunque como se puede ver presenta también importantes
diferencias.
Existen situaciones en que una de diferentes alternativas es la única a ejecutar y la selección de
dicha alternativa depende del valor de una expresión de tipo integral. Se dice entonces que cada
posible ejecución alternativa es un caso y que la expresión cuyo valor permite escoger el caso a
ejecutar es un selector. La instrucción que permite representar tal situación se denomina de
selección por casos.
Ejemplo 3.7
Analicemos el siguiente problema: dado un mes y un año, determinar cuántos días tiene ese mes.
En la solución del problema hay que tener en cuenta para el mes de febrero si el año es bisiesto o
no.
Entradas: Mes (codificado numéricamente de 1 a 12) y año.
Salida: Cantidad de días del mes.
Método:
• Esta claro que para los meses de Enero, Marzo, Mayo, Julio, Agosto, Octubre y Diciembre,
la cantidad de días es 31;
• para los meses de Abril, Junio, Septiembre y Noviembre es 30;
• en el caso de Febrero, si el año es bisiesto (es múltiplo de 4 y si es un año múltiplo de 100
lo es también de 400) entonces la cantidad de días es 29, si no es bisiesto es 28.
Si analizamos el algoritmo de solución, este se basa en tratar tres alternativas excluyentes (que
dependen de cada grupo de meses) y que el selector es por tanto el mes.
Para escribir el programa completo, demos antes la forma general de la instrucción de selección por
casos:
switch ( expresión_selector )
{
case valor_constante :
instrucción
................
default :
instrucción_alternativa
}
que es ejecutada así: se evalúa la expresión_selector ; si su valor coincide con algún
valor_constante , se ejecuta la instrucción correspondiente, si no coincide con ninguna se ejecuta la
instrucción_alternativa después de default, si esa clausura existe, de lo contrario se pasa a ejecutar
la instrucción que viene a continuación. Es importante señalar que cada instrucción que siga a un
valor constante debe contener como última instrucción un break para garantizar la continuidad de
la ejecución del programa y evitar que una vez ejecutado el caso correspondiente se pase a ejecutar
el siguiente.

Puede parecer una desventaja pero a veces es conveniente. Por ejemplo cuando dos case deben
tener el mismo código. Si no tuviéramos esta posibilidad tendríamos que escribir dos veces el
mismo código. (Claro, también podríamos usar funciones, pero si el código es corto puede ser más
conveniente no usar funciones. Ya hablaremos de eso más tarde.).

Ahora damos el programa del ejemplo 3.7 para el cálculo de la cantidad de días de un mes.

#include <iostream.h>
#include <conio.h>
// Determinación de la cantidad de días de un mes
void main()
{ int mes, ano, cantidad;
cout <<"Entre el mes: ";
cin >> mes;
cout <<"Entre el año: ";
cin >> ano;
switch (mes)
{ case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12: cantidad=31;
break;
case 4:
case 6:
case 9:
case 11: cantidad=30;
break;
case 2: if ((ano % 400==0)||((ano % 100 !=0)&&(ano % 4 ==0)))
cantidad=29;
else
cantidad=28;
};
cout <<"El mes " <<mes <<" del año " <<ano <<" tiene " <<cantidad <<"dias";
getch();
}

Observemos el segmento:
case 4:
case 6:
case 9:
case 11: cantidad=30;
break;

Note que como queremos ejecutar la asignación cantidad=30; para diferentes casos del selector,
estos deben ser escritos para etiquetar la instrucción a ejecutar, escribiendo cada vez la palabra case
y luego el valor constante del caso. La instrucción break desvía la ejecución hacia la instrucción
que sigue al case, en este caso cout....... y evita que una vez evaluado un caso pasemos al caso
siguiente if ((ano.....

El SWITCH es una forma sencilla de evitar largos, tediosos y confusos anidamientos de ELSE-IF.