Estructura básica de un programa en C++

C++:
El lenguaje de programación que veremos a continuación es el Lenguaje C++.
Este lenguaje pertenece a la clase de lenguajes comúnmente llamados híbridos,
pues soportan dos filosofías distintas de programación: la primera la que veremos
a lo largo de este curso: la programación estructurada; la segunda de estas
filosofías es la programación orientada a objetos, POO.
El lenguaje C++ es algo así como una versión mejorada del lenguaje C, con lo
cual cualquier programa escrito en el lenguaje C también es un programa C++. El
Lenguaje C++ es un lenguaje de programación de propósito general, es decir, es
posible escribir cualquier tipo de programas con él, incluyendo programas
específicos de tipo matemáticos.
Es un lenguaje de programación diseñado a mediados de los años 1980 por
Bjarne Stroustrup, un lenguaje de programación C con mecanismos que permiten
la manipulación de objetos, desde el punto de vista de los lenguajes orientados a
objetos, el C++ es un lenguaje híbrido.
La única forma de aprender un nuevo lenguaje de programación es escribiendo
algunos programas en él y describirlo a partir de estos.
Imprimir las palabras => Hola sección, esto es "C++".
#include <iostream.h>
main()
{
cout << "Hola sección, esto es \"C++\"\n";
}
Un programa en C++ cualquiera sea su tamaño, consta de funciones y variables.
Una función contiene proposiciones que especifican las operaciones de cálculo
que se van a realizar, y a las variables que almacenan los valores utilizados
durante los cálculos. Nuestro ejemplo es una función llamada main. Normalmente
se tiene la libertad de dar cualquier nombre que se desee a una función, pero main
es especial, el programa siempre debe tener un main, porque el programa
comienza a ejecutarse a partir de él.
La primera línea:
#include <iostream.h>
Indica al compilador que incluya información acerca de algunas de las funciones
que luego se usaran en el programa y que están definidas en esta biblioteca o
comúnmente llamada "librería".
Un método para comunicar datos entre las funciones es que la función que llama,
proporciona una lista de valores, llamados argumentos, a la función a la que se
está invocando. Los paréntesis que están después del nombre de la función
encierran a la lista de argumentos. En este ejemplo, main está definido para ser
una función que no espera argumentos, lo cual esta indicado por la lista vacía ().
Las proposiciones de una función están encerradas entre llaves {...}, las que
indican el comienzo y el final del bloque de instrucciones de un programa.
En nuestro ejemplo
cout << "Hola Mundo, esto es \"C++\"\n";
cout es un identificador asociado a un dispositivo de salida, en particular la
pantalla, este identificador esta definido en la librería <iostream.h> y lo que
hace el operador << es enviar hacia la pantalla los argumentos recibidos, \" y \n
son denominadas secuencias de escape, \" es el caracter comillas, la función que
cumple aquí es evitar que se malinterprete un final de string (cadena de
caracteres), \n es para que se imprima una nueva línea luego de imprimir el o los
argumento/s que contiene. Si se omite \n, no habrá avance de línea puesto cout
no lo proporciona.
Nuestro programa también se hubiera podido escribir así:
#include <iostream.h>
main()
{
cout << "Hola ";
cout << "Mundo ";
cout << "Esto es \"C++\"\n";
}
Variables y Expresiones Aritméticas
El siguiente Programa utiliza la formula ºC=(5/9)x(ºF-32) para imprimir una tabla
de temperaturas Fahrenheit y sus equivalentes en grados centígrados o Celsius.
#include <iostream.h>
/* Imprime la tabla Faherenheit-Celsius para
fahr=0,20,40,...,300 */
main()
{
int fahr,celsius;
int minima,maxima,paso;
minima=fahr=0; // temperatura mínima de la tabla
maxima=300; // temperatura máxima de la tabla
paso=20; // tamaño del incremento
while(fahr <= maxima)
{
celsius=5*(fahr-32)/9;
cout << fahr << "\t" << celsius;
fahr=fahr+paso;
}
}
Las dos líneas encerradas entre /* y */ o también los caracteres después de // son
comentarios. En C++ se deben declarar todas las variables antes de su uso,
generalmente al principio de la función y antes de cualquier proposición
ejecutable. Una declaración notifica las propiedades de una variable, consta de un
nombre de tipo y una lista de variables como:
int fahr,celsius;
\t hace que los valores de los dos enteros fahr y celsius se impriman como valores
enteros con una tabulación (\t) entre ellos. El ciclo while funciona de la siguiente
manera: se prueba la condición entre paréntesis (fahr <= maxima). De ser
verdadera, el cuerpo del ciclo (definido entre llaves) se ejecuta. El cuerpo del ciclo
puede tener una o mas proposiciones, si solo tiene una, no es necesario
encerrarla entre llaves como por ejemplo: while(i < j) i=i*2;
La razón de multiplicar por 5 y después dividir por 9 es que en C++ como en la
mayoría de los otros lenguajes, la división de enteros trunca el resultado: cualquier
parte fraccionaria se descarta puesto que 5 y 9 son enteros, 5/9 sería truncado a 0
y todas las temperaturas se reportarían como 0.
Existe un problema aquí, debido a que se ha utilizado aritmética de enteros, las
temperaturas Celsius no son muy precisas; por ejemplo, 0 ºF es en realidad
aproximadamente -17.78 ºC no 17 ºC como se reportaría. Para obtener soluciones
mas precisas se debe utilizar aritmética de punto flotante, a saber:
#include <iostream.h>
/* Imprime la tabla Faherenheit-Celsius para
fahr=0,20,40,...,300 */
main()
{
float fahr,celsius; // Punto flotante de simple precision
int minima,maxima,paso; // Tipo de dato entero
minima=fahr=0; // Temperatura mínima de la tabla
maxima=300; // Temperatura máxima de la tabla
paso=20; // Tamaño del incremento
while(fahr <= maxima)
{
celsius=(5.0/9.0)*(fahr-32.0);
cout << fahr << "\t" << celsius;
fahr=fahr+paso;
}
}
Existen suficientes formas de escribir un programa para una tarea en particular.
Observemos el mismo programa de temperaturas.
#Include <iostream.h>
/* Imprime la tabla Faherenheit-Celsius para
fahr=0,20,...,300 */
main()
{
int fahr;
for(fahr = 0 ; fahr <= 300 ; fahr = fahr + 20)
cout << fahr << "\t" << (5.0/9.0)*(fahr-32.0);
}
Produce los mismos resultados que los programas anteriores, pero ciertamente se
ve diferente. Un cambio importante es la eliminación de la mayoría de las
variables; solo permanece fahr y la hemos hecho entera (int).
La proposición for es un ciclo, una forma generalizada del while. Dentro de los
paréntesis existen tres secciones separadas por punto y coma. La primera vez, la
inicialización se ejecuta una vez, antes de entrar propiamente al ciclo. La segunda
sección es la condición que controla el ciclo: fahr <= 300;. Esta condición se
evalúa si es verdadera, el cuerpo del ciclo (en este caso un simple cout) se
ejecuta. Después el incremento de avance: fahr=fahr+20; se ejecuta y la condición
se vuelve a evaluar. El ciclo termina si la condición es falsa. Tal como con el while,
el cuerpo del ciclo puede ser una proposición sencilla o un grupo de proposiciones
encerradas entre llaves. La inicialización, la condición y el incremento pueden ser
cualquier expresión. La elección entre el while y el for es arbitraria y se basa en
aquello que parezca más claro. El for es por lo general apropiado para ciclos en
los que la inicialización y el incremento son expresiones sencillas y lógicamente
relacionadas, puesto que es mas compacto que el while y mantiene reunidas en
un lugar a las proposiciones que controlan el ciclo.
Una observación final antes de dejar el tema de conversiones de temperaturas. Es
una mala práctica poner "números mágicos" como 300 y 20 en un programa, ya
que proporciona muy poca información a quien tenga que leer el programa y son
difíciles de modificar en forma sistemática.
Una línea #define define un nombre simbólico o constante simbólica, como una
cadena de caracteres especial:
#define nombre texto de reemplazo
#include <iostream.h>
#define MAXIMA 300 // TEMPERATURA FAHRENHEIT MAXIMA
#define MINIMA 0 // TEMPERATURA FAHRENHEIT MINIMA
#define PASO 20 // TAMAÑO DEL INCREMENTO
/* Imprime la tabla Faherenheit-Celsius */
main()
{
int fahr;
for(fahr = MINIMA ;fahr <= MAXIMA; fahr = fahr + PASO)
cout << fahr << "\t" << (5.0/9.0)*(fahr-32.0);
}
*Nótese que no hay punto y coma después de la línea #define.
Todo lo visto, debe servir para orientarlos en la filosofía del lenguaje, en el estilo y
estructuración. Ahora dejaremos un poco estas ejemplificaciones y seremos más
concretos en los aspectos de este lenguaje.
Tipos, Operadores y Expresiones
Existen algunas restricciones en los nombres de las variables y de las constantes.
El primer caracter debe ser una letra. El caracter de subrayado también es válido,
pero no es aconsejable que una variable comience con tal caracter, dado que la
mayoría de las rutinas de las librerías anexas usan tal caracter como característica
en sus nombres.
Las letras mayúsculas y minúsculas son distintas, de tal manera x y X son dos
nombres diferentes. La práctica tradicional y mas aconsejable en C++ es usar
letras minúsculas para nombres de variables y todo en mayúsculas para nombres
de constantes.
Las palabras claves o reservadas, no se deben utilizar como variables. Todas
deben escribirse con minúsculas.
Los siguientes identificadores son palabras reservadas:
auto double int struct
break else long switch
case enum register typedef
char extern return union
const float short unsigned
continue for signed void
default goto sizeof volatile
do if static while
asm _cs _ds _es
catch friend operator public

class inline overload template

_ss cdecl far huge
delete new private this
interrup near pascal throw
t
try virtual catch
Tipos básicos de datos, declaraciones.
Las declaraciones especifican la interpretación dada a cada identificador (variable
o constante). El formato sería:
 Especificador-categoría-almacenamiento
 Especificador-de-tipo tipo lista de declaraciones.
Especificadores de categoría de almacenamiento.
 auto
 register
 static
 extern

Existen dos categorías de almacenamiento: la automática y la estática. Los

objetos automáticos son locales a un bloque y son descartados al salir del bloque.
Las declaraciones dentro de un bloque crean objetos automáticos si no se emplea
el especificador auto.
1. Los objetos declarados como register son automáticos y sugiere que se
harán acceso frecuente a los objetos declarados y se almacenan (si es
posible) en los registros rápidos de la máquina. Para los objetos declarados
como auto no es necesario especificar esta condicion puesto que cada
variable dentro de un bloque al que pertenece es automática, es decir es su
espacio es creado al entrar al bloque.
2. Los objetos estáticos pueden ser locales a un bloque o externos a todos
los bloques pero, en cualquier caso, mantiene su valor entre las salidas y
reentradas a funciones o bloques. Las palabras reservadas static y extern
declaran objetos estáticos.
Especificadores de tipos de datos.
 signed
 unsigned
 long
 short
Estos especificadores de tipos se pueden aplicar a los tipos enteros y a los tipos
caracteres. Modificadores de acceso.—
C++ incorpora dos especificadores de tipos, que se utilizan para controlar las
formas en que un programa accede o modifica las variables que usa. Estos
modificadores son:
 const
 volatile
Las constantes.—
Existen varias clases de constantes, a saber:
 Constantes enteras
 Constantes de caracteres
 Constantes de punto flotante
 Constantes de enumeración
 Constantes simbólicas
#define texto nombre de reemplazo
Ejemplos:
#define BELL ´\007´ // caracter campana usando secuencias de escape en octal
#define BELL ´\x7´ // caracter campana usando secuencias de escape en
hexadecimal
#define BELL ´\a´ // caracter campana usando secuencias de escape

Tres formas diferentes de definir el caracter campana ASCII.

#define TRUE 1
#define FALSE 0

Muy útil, dado que el tipo de dato booleano no existe en C++.

#define CADENA "Hola seccion, esto es C++"
#define MAXIMO 12523646342.234LF
#define COMILLAS ´\"´

Todas las constantes también pueden ser declaradas con el modificador de

acceso const.
const int ENTERO=-237;
const float PI=3.141592;
const double PI_D=3.1415926536;
const long double E=2.71828182845904523536
const char msg[]="Hola mundo, esto es C++";
Operadores.—
1. Aritméticos.
Los operadores aritméticos son:
* , / , % (operador módulo para enteros)
+,-
en orden de precedencia.
2. Lógicos y de relación.
Los operadores de relación son:
> , >= , < , <=
Todos ellos tienen la misma precedencia.
3. Bajo ellos en precedencia están los operadores de igualdad:
== , !=
Los operadores aritméticos tienen mayor precedencia que los operadores de
relación, una expresión como:
i < lim-1 se toma como i < (lim-1) como se esperaría.
4. Los operadores lógicos son:
&& y || (and y or)
5. Operadores de Incremento y decremento.
El lenguaje C o el C++ proporcionan dos operadores muy propios y poco
comunes. El operador de aumento ++ agrega 1 a su operando, ent tanto que el
operador de disminución -- le resta 1.
Los dos operandos son susceptibles de ubicarse como prefijos o sufijos, por
ejemplo:
i = i + 1; es equivalente a: ++i, o bien i++
i = i - 1; es equivalente a: --i, o bien i--
(++i,--i) o (i++,i--) Para el primer paréntesis los efectos del operador son
incrementar o decrementar a las variables antes de que su valor se utilice, para el
segundo paréntesis es incrementar o decrementar las variables despues de
utilizada la variable.
Operadores de asignación y expresiones.
Si expr1 y expr2 son dos expresiones, entonces:
expr1 op= expr2
es equivalente a:
expr1 = (expr1 ) op (expr2 );
donde op puede ser cualquiera de:
+,-,*,/,%
<< , >> , & , ^ , | (operadores para manejos de bits)
Ejemplos:
x *= (y + 1); Þ x = x * (y + 1);
x += 2; Þ x = x + 2;
Aquí una lista mas completa:
+= , -= , *= , /= , %= , &= , ^= , |= , <<= , >>= .
6. El operador ternario ?.—
C++ contiene un operador muy potente y conveniente que puede usarse para
sustituir ciertas sentencias de la forma if-then-else. Este operador toma la forma
general:
expr1 ? expr2 : expr3 ;
Ejemplo:
x=10;
y = (x > 9) ? 100 : 200 ;
Es equivalente a:
x=10;
if(x > 9)
y = 100;
else
y = 200;
Ambas porciones de código, asigna a la variable y el valor 100.
Proposiciones y bloques.—
Una expresión como x = 0 ó i++ o cout << ... se convierte en una proposición
cuando va seguida de un punto y coma, como en:
x = 0;
i++;
cout << .... ;
En C o C++, el punto y coma es un terminador de proposición. Las llaves { } se
emplean para agrupar declaraciones y proposiciones dentro de una proposición
compuesta o bloque. No hay punto y coma después de la llave } de cierre de un
bloque.
If-else.—
Formalmente la sintaxis es:
Ejemplo:
if(expresión) if(a<b)
z=a;
proposición1;
else [else
proposición2; z =b;]

Los puntos y comas en proposicion1 y proposición2 dan la aclaración mencionada.

Los corchetes en la cláusula else indica que ésta es opcional. Debido a esto,
existe una ambigüedad cuando un else se omite de una sentencia if anidada.
Por ejemplo:
if(n > 0) El else va con el if mas if(n >0) {
interno como se muestra
if(a < b) if(a < b)
en el sangrado. Si esto
z = a; no es lo que se desea, z = a;
se deben utilizar las
else llaves para forzar la }
z = b; asociación correcta o else
deseada.
z = b;
Else-if.—
La construcción es:
if(expresión)
proposición1;
else if(expresión) Esta secuencia de proposiciones if es la
forma general de escribir una decisión
proposición2;
múltiple. Las expresiones se evalúan en
else if(expresión) orden, si cualquier expresión es verdadera,
la proposición asociada con ella se ejecuta,
proposición3; y esto termina toda la cadena. Como
else siempre, el código para cada proposición
es una proposición simple o un grupo
proposición4; dentro de llaves.
La parte del ultimo else maneja el caso
"ninguna de las anteriores", esta también
puede omitirse

Switch.—
La proposición switch es una decisión múltiple que prueba si una expresión
coincide con uno de un número de valores constantes (casos) enteros, y traslada
el control adecuadamente:
switch(expresión) { Dentro de cada case y como proposición
final, debe ir la proposición break, para que
case exp-constante :
la selección culmine con la ocurrencia del
proposición1;
caso único que se ha cumplido. La clausula
case exp-constante : default es opcional
proposición2;
case exp-constante :
proposición3;
default : proposición4;
}
Ciclos - whiles - for - do-while.—
Ya hemos visto anteriormente los ciclos for y while.
while(expresión)
proposición;
La proposición for:
for(expr1; expr2; expr3)
proposición;
es equivalente a:
expr1;
while(expr2) {
proposición;
expr3;
}
El usar while o for es principalmente cuestión de preferencia personal. El for se
prefiere cuando existe inicialización simple e incrementos, puesto que mantiene
las proposiciones de control del ciclo juntas y visible al principio del mismo.
Tanto el índice como el límite de un ciclo for en C++ pueden ser alterados desde
dentro del ciclo, y la variable del índice retiene su valor cuando las iteraciones
terminan por cualquier razón. Debido a que los componentes de for son
expresiones arbitrarias, sus ciclos no están restringidos a progresiones
aritméticas.
Los ciclos while y for verifican al principio la condición de término. En contraste, el
tercer ciclo en C++, el do-while, prueba al final después de realizar cada paso a
través del cuerpo del ciclo, el cual se ejecuta siempre por lo menos una vez.
La sintaxis del do es:
do
proposición;
while(expresión);
El ciclo do-while en C++ es igual que el while pero la salvedad está en que la
verificación de la condición se hace al final. Luego si el ciclo va acompañado de
varias proposiciones deben encerrarse entre llaves, después del do y antes del
while.
Operaciones de entrada/salida
El archivo de cabecera iostream.h, está definido en C++ y se usa para las
operaciones de entrada y salida. Por ejemplo:
cout << "Me gusta Turbo C++.\n";
Muestra en pantalla "Me gusta Turbo C++." Seguido por la combinación de un
salto de carro y salto de línea. En C++, el símbolo << tiene un cometido más
amplio sigue siendo el operador de desplazamiento a la izquierda, pero cuando se
usa como se muestra en este ejemplo, también es un operador de salida. La
palabra cout es un identificador que esta asociado a la pantalla. Al igual que C, C+
+ permite la redirección de la E/S, pero por lo que respecta a esta explicación,
asumiremos que cout se refiere a la pantalla. Se puede usar cout y el símbolo <<
para mostrar cualquiera de los tipos de datos incorporados o predefinidos, además
de las cadenas de caracteres.
Si nuestro programa requiere que ingresemos algo desde el teclado, procedemos,
por ejemplo:
cin >> i;
El número se lee a través del teclado usando la sentencia cin. El identificador cin
se refiere al teclado. En general se usa cin >> para cargar un valor en una variable
cualquiera de los tipos básicos de datos o cadenas.
Uso de los manipuladores.—
El sistema de E/S de C++ incluye una forma de alterar los parámetros de formato
de E/S. Para esto se usan unas funciones especiales llamadas manipuladores,
que se pueden incluir en las operaciones de E/S.
Estructura de Bloques
C o C++ no es un lenguaje estructurado en bloques, puesto que las funciones no
se pueden definir dentro de otras funciones. Por otra parte las variables
(incluyendo la inicialización) pueden seguir a la llave izquierda que indica cualquier
proposición compuesta, no solo la que inicia a una función. Las variables pueden
declaradas de esta manera, cualquier nombre idéntico de variables de bloques
más externos, son totalmente distintas, y permanecen hasta que se encuentra la
llave derecha que se corresponde con la inicial. Por ejemplo en:
if(n > 0) {
int i;
for(i=0;i < n;++i)
.......
}
i=3;
La i del bloque if-else se declara al entrar al bloque y se destruye al salir de él, es
por ello que no tiene nada que ver la variable i externa al bloque.
Inicialización
La inicialización de una variable puede llevarse a cabo en el momento de su
declaración. Para ello se procede a declararla y luego el signo igual y los valores
de inicialización, por ejemplo:
int i=0;
char letra='A';
double sala=200.39;
En ausencia de declaración explícita, se garantiza que las variables externas y
estáticas se inicializan en 0; las variables automáticas y tipo registro tienen valores
iniciales indefinidos (basura).