PDF de programación - Tutor de C++

Lección 1

De acuerdo a su definición, C++ es una extensión del lenguaje C, un supercunjunto, esto implica para
quién decide iniciar sus estudios en C++ que para empezar dispone de un lenguaje completo como soporte a
los nuevos conceptos introducidos por C++, esto significa que todo lo que podemos programar en ANSI-C
funciona en C++ y esto a su vez es una buena razón para afirmar la importancia que tiene en el aprendizaje
de C++ el conocimiento previo del lenguaje C, por lo tanto se supone que el lector está familiarizado con
todo lo expuesto en el curso en línea de la sección programando en C.

Comentarios en C++

Es natural tratar en primer lugar la manera de hacer comentarios en el código fuente de un programa
escrito en C++, y para probar la afirmación hecha en el párrafo anterior, el siguiente código escrito en C debe
compilar perfectamente. Le llamaremos al código comenta1.cpp, habrá notado que la extensión *.cpp se
refiere a C-plus-plus. Un compilador de C++ sabe que el código está escrito en C++ precisamente por la
extensión del archivo que contiene el código fuente.


/******************************************/
/* comenta1.cpp */
/******************************************/

#include <stdio.h>

int main()
{
float corriente, voltaje, resistencia; /* tres variables */

printf("Este programa calcula volaje de acuerdo a la ley de Ohm\n");
printf("Valor de la corriente, en amperes?\n");
scanf("%f", &corriente);
printf("Valor de la resistencia, en ohms?\n");
scanf("%f", &resistencia);

voltaje=corriente*resistencia; /* calculo de voltaje */

printf("El valor del voltaje es de %f voltios\n", voltaje);

return 0;
}

Aunque se trata de un programa escrito en C, por la sencilla razón de que el archivo de código fuente
lleva la extensión *.cpp, el compilador lo trata como un código C++ válido, esto demuestra la total
compatibilidad de que disponemos al programar en C++ con respecto al lenguaje C. Empero C++ introduce
una manera más práctica de hacer comentarios al utilizar doblemente el símbolo de barra inclinada para
indicarle al compilador que el resto de la línea de código que sigue a la doble barra inclinada es un
comentario y por lo tanto debe ignorarse en el proceso de compilación. Al contrario del mecanismo para
hacer comentarios en C que puede abarcar varias líneas de código, el estilo utilizado en C++ sólo es válido
hasta el final del renglón en donde es utilizada la doble barra inclinada. Ahora nuestro programa lo
modificamos para utilizar comentarios en C++:


//******************************************
// comenta2.cpp

//******************************************

#include <stdio.h>

int main()
{
float corriente, voltaje, resistencia; // tres variables

printf("Este programa calcula volaje de acuerdo a la ley de Ohm\n");
printf("Valor de la corriente, en amperes?\n");
scanf("%f", &corriente);
printf("Valor de la resistencia, en ohms?\n");
scanf("%f", &resistencia);

voltaje=corriente*resistencia; // calculo de voltaje


printf("El valor del voltaje es de %f voltios\n", voltaje);

return 0;
}

Se aprecia de inmediato la comodidad del nuevo estilo de introducir comentarios en el código fuente de
C++ además del doble beneficio que representa el poder seguir utilizando los comentarios en C. Se debe
tener ciertas precauciones al manejar los comentarios pues aunque C++ reconoce ambos métodos, el estándar
ANSI-C en sí no reconoce la mecánica de C++ para los comentarios, dicho en otras palabras, no escriba
código en ANSI-C pensando en términos de C++, lo contrario, como ya lo probamos, es perfectamente
válido.

Volver al principio

La librería iostream.h

Aunque comenta2.cpp es un programa C++ válido sabemos que es en realidad un programa escrito en C y
nosotros estamos interesados en aprender los aspectos nuevos introducidos en C++, pues bien, un cambio
muy importante es en la manera en que se maneja la entrada y salida de datos en el programa. Al igual que
en C, C++ no incluye operaciones de entrada y salida como parte del lenguaje en sí, en cambio define la
librería iostream que agrega funciones de entrada y salida muy elegantes. Al programar en C nos
familiarizamos con el archivo stdio.h en donde está definida entre otras, la función printf() que como
sabemos sirve para escribir datos en el dispositivo estándar de salida, que en la gran mayoría de los casos es
el monitor de la computadora. Como la función printf() se desarrolló casi desde los origenes de C, la función
ha sufrido una serie de transformaciones que la ha hecho crecer en tamaño, como resultado de esto, cuando
incluimos la función printf() en nuestro programa C tambien incluimos todas las opciones agregadas con el
tiempo aunque no las utilicemos. Un caso similar sucede con la función scanf().

C++ propone una solución muy interesante al tratar las operaciones de entrada-salida (E/S) no como una
función, sino como una clase que implementa una gran capacidad de formatos para entrada y salida de datos,
de ésta manera el programador C++ toma sólo las carácterísticas que el trabajo requiere. Aunque no hemos
definido qué es una clase, tenga en cuenta que en C++ las operaciones de E/S están definidas en una clase,
éste es un punto importante. Existen cuatro flujos de E/S (iostreams) predefinidos:

cin, asociado al dispositivo de entrada estándar.
cout, asociado al dispositivo de salida estándar.
cerr, asociado al dispositivo de error estándar.
clog, salida almacenada temporalmente para el dispositivo de error estándar.

Tomando en cuenta lo dicho estamos en condición de modificar el programa anterior para utilizar los
flujos de E/S, de ésta manera ya no necesitamos el archivo de cabecera stdio.h el cual lo hemos sustituido por
el archivo iostream.h que nos permite utilizar los flujos de E/S


//******************************************
// entsal.cpp
//******************************************

#include <iostream.h>

int main()
{
float corriente, voltaje, resistencia; // tres variables

cout << "Este programa calcula volaje de acuerdo a la ley de Ohm\n";
cout << "Valor de la corriente, en amperes?\n";
cin >> corriente;
cout << "Valor de la resistencia, en ohms?\n";
cin >> resistencia;

voltaje=corriente*resistencia; // calculo de voltaje

cout << "El valor del voltaje es de " << voltaje << " voltios\n";

return 0;
}

El programa entsal.cpp es idéntico a comenta2.cpp, sin embargo es importante hacer notar lo siguiente, no
se recomienda mezclar la función printf() con el flujo de salida cout en el mismo programa ya que se
generarían dos flujos independientes hacia el mismo dispositivo de salida con resultados impredecibles.
Comparando los dos últimos programas es fácil asimilar el uso de cin y cout. Utilizamos el flujo de salida
cout en conjunción con el operador de inserción, << para mostrar un mensaje en la pantalla del monitor. De
manera similar, utilizamos el flujo de entrada cin en conjunción con el operador de extracción, >> para
asignar un valor a las variables llamadas corriente y resistencia. Observe que no es necesario utilizar el
operador de dirección & con las variables de entrada. La línea 19 demuestra el uso de varios operadores de
inserción en una sola línea de código, observe que las cadenas y los datos se despliegan en el orden en que se
escriben en la línea de código, tambien observe el espacio en blanco al final de la primera cadena y al
principio de la segunda cadena de ésta línea de código.

En términos generales declaramos el archivo de cabecera iostream.h para operaciones de flujos de E/S,
éste suele incluir otros archivos de cabecera adicionales que declaran funciones, macros, clases y valores
necesarios en las operaciones con flujos de entrada (istream.h), flujos de salida (ostream.h), buffers de flujos
(streamb.h) y manipuladores de flujo (imanip.h) principalmente. Analizaremos éstas tres partes por separado.

Volver al principio

Utilizando manipuladores

Un manipulador es un valor que podemos extraer ó insertar de un flujo de E/S para lograr un efecto
especial en estos. Un manipulador parece un objeto que insertamos ó extraemos de un flujo pero
generalmente solo cambia el estado del mismo. Existen tres manipuladores comunes, dec, oct y hex los
cuales permiten desplegar un valor numérico en base decimal, octal y hexadecimal respectivamente, y otros
más declarados en el archivo iomanip.h entre los que figuran setw(), setfill(), setprecision(), setiosflags() y
resetiosflags().

Manipuladores básicos

En el siguiente programa, manipu01.cpp, se demuestra el uso de los manipuladores básicos oct, hex, y
dec. El programa inicia solicitándole introducir un número, mismo que se almacena en la variable de tipo int
llamada numero, en forma predeterminada, el sistema despliega los valores numéricos utilizando la base 10,
esto se demuestra en el primer mensaje desplegado por el programa en la línea 14. Enseguida se utiliza el
operador de inserción (<<) para introducir el manipulador oct que cambia la base para despliegue numérico a
octal por lo que el valor contenido en la variable llamada numero se despliega en pantalla en su equivalente
de base 8. Observe que el contenido de la variable no ha cambiado, solo se modifica la forma para desplegar
un valor numérico en el dispositivo estándar de salida.


//*********************************************************
// manipu01.cpp
//*********************************************************

#include <iostream.h>

int main()
{
int numero;

cout <<"Introduzca un numero"