Introducción <Subir>

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.
Comencemos.—
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 Mundo, esto es "C++".
#include <iostream.h>
main()
{
cout << "Hola Mundo, 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 comÚnicar 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 <Subir>

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 <Subir>

Nombre de los identificadores

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
interrupt near pascal throw
try virtual catch
Tipos básicos de datos, declaraciones <Subir>

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. Estas modificadores son:
• const
• volatile
Todas las combinaciones posibles de especificadores de tipos y tipos
posibles en Turbo C++.—
 TIPO LONGITUD RANGO

Tiene tres tipos de usos que luego se

void ------
explicaran.

char 8 bits -128 a 127

unsigned char 8 bits 0 a 255

signed char 8 bits -128 a 127

enum 16 bits -32.768 a 32.767

int 16 bits -32.768 a 32.767

unsigned int 16 bits 0 a 65.535

signed int 16 bits -32.768 a 32.767

short int 16 bits -32.768 a 32.767

unsigned short
16 bits 0 a 65.535
int
signed short int 16 bits -32.768 a 32.767

long int 32 bits -2.147.483.648 a 2.147483.647

unsigned long 32 bits 0 a 4.294.967.295

signed long int 32 bits -2.147.483.648 a 2.147483.647

float 32 bits 3.4 * (10**-38) a 3.4 * (10**+38)

double 64 bits 1.7 * (10**-308) a 1.7 * (10**+308)

long double 80 bits 3.4 * (10**-4932) a 1.1 * (10**+4932)

Para los ejemplos: 4,8,11,14; se puede omitir declararlos con el

especificador signed. Sin embargo para obtener un tipo de dato no
signado se debe especificar unsigned, este especificador no tiene
efecto con los tipos de datos de punto flotante.
• El tipo void (nada) tiene tres usos.
1. Cuando se coloca como declarador de tipo en una función significa
que es una función que no retorna valor alguno.
2. Cuando se declaran los argumentos de una función, colocar void
entre los paréntesis, indique de manera explícita que la función no
recibe valores de argumento.
 3. Como declarador para punteros genéricos.
• Las constantes.—
Existen varias clases de constantes, a saber:
1. constantes enteras
2. constantes de caracteres
3. constantes de punto flotante
4. constantes de enumeración
5. constantes simbólicas
Ejemplos de cada una:
1. Las constantes enteras pueden ser de cualquiera de los tipos
enteros, ademas pueden tomar valores decimales, octales o
hexadecimales:

Tipos de Enteros Enteros decimales Enteros octales Enteros hexadecimal

int 123 012 0x1a o 0X1A
long 1234567l ó L 0123456l ó L 0x1al ó L ó 0X1ABl ó L
unsigned 1234u ó U 012u ó U 0x1au ó 0X1AU
0x1aul ó UL ó 0X1Aul ó
unsigned long 12345678 ul ó UL 0123456ul ó UL
UL
2. Los sufijos en cada constante no son necesarios especificar, sin
embargo pueden ayudar a determinar bien que tipo de datos es el
que es constante.
3. Las constantes de caracteres pueden ser de dos tipos:
El primer tipo, es el que corresponde a un caracter que es igual al
valor ASCII del caracter representado, este deberá estar
encerrado entre apóstrofe: ´A´, ´x´, ´h´ , etc.
También pertenecen a este tipo las denominadas "secuencias de
escape", las constantes de caracter, están representadas de igual
forma con la salvedad de que después del apóstrofe le sigue una
barra invertida, como:

´\a´ caracter de alarma (beep) ´\\´ diagonal invertida

´\b´ retroceso ´\?´ interrogación

´\f´ avance de hoja ´\´´ apóstrofe

´\n´ avance de linea ´\"´ comillas

´\r´ regreso de carro ´\000´ número octal

´\t´ tabulador horizontal ´\xhh´ número hexadecimal

 ´\v´ tabulador vertical ´\0´ caracter nulo

El segundo tipo es un conjunto de caracteres encerrados entre

comillas llamados por lo general strings:
"HOLA QUE TAL ESTO ES UN EJEMPLO"
4. Las constantes de punto flotante tienen un punto decimal o un
exponente y/o los sufijos f ó F y l ó L.
Tipo float 123.45f ó F 1.234e+34
Tipo double 123.478283829232lf ó lF 1.23478283e+200
Tipo long double 1.267282749502238737362732LF o Lf
1.26727495e+450
5. Otra forma de definir las secuencias de escape a través de
constantes de enumeración. Las constantes de enumeración se
definen del siguiente modo:
enum boolean {FALSE,TRUE};
La primera constante de enumeración dentro de las llaves tiene el
valor 0 la siguiente el 1. Si no se les asignan valores explícitos en
orden ascendente, la inicialización comienza desde 0 cero y
continua en orden progresivo hasta terminarse la lista de
declaraciones.
enum escapes { BELL=´\a´,RETROCESO=´\b´,TAB=´\t´, NVALIN=´\n´,
VTAB=´\v´,RETURN=´\r´};
6. Las constantes simbólicas son constantes que pueden ser
expresiones de cualquier tipo. Una constante de este tipo se
define de la siguiente manera:
#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 mundo, 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.
6. 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:
+= , -= , *= , /= , %= , &= , ^= , |= , <<= , >>= .
7. 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.

Control de flujos <Subir>

Las proposiciones de control de flujo de un lenguaje especifican el

orden en que se realiza el procesamiento. Ya hemos visto algunas, aquí
completaremos el conjunto y seremos específicos en sus declaraciones.
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:

if(expresión) Ejemplo: if(a<b)

proposición1; z=a;
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:

El else va con el if
mas interno como se
if(n >0) {
if(n > 0) muestra en el
if(a < b)
if(a < b) sangrado. Si esto no
z = a;
z = a; es lo que se desea,
}
else se deben utilizar las
else
z = b; llaves para forzar la
z = b;
asociación correcta o
deseada.

Else-if.—
La construcción es:

if(expresión) Esta secuencia de proposiciones if es

la forma general de escribir una
proposición1; decisión múltiple. Las expresiones se
else evalúan en orden, si cualquier
if(expresión) expresión es verdadera, la
proposición asociada con ella se
 proposición2; ejecuta, y esto termina toda la
else cadena. Como siempre, el código
if(expresión) para cada proposición es una
proposición simple o un grupo dentro
proposición3; de llaves.
else La parte del ultimo else maneja el
caso "ninguna de las anteriores",
proposición4; 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
case exp-constante proposición break, para que la
: proposición1; selección culmine con la
case exp- ocurrencia del caso único que se
constante : ha cumplido. La clausula
proposición2; default es opcional
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 <Subir>

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.
Los manipuladores estándar se muestran a continuación:

Manipulador Propósito Entrada/Salida

dec Formato de datos numéricos en Entrada/Salida
decimal.

endl Salida de un caracter de nueva Salida

linea y vaciado del flujo.

ends Salida de un caracter nulo. Salida

flush Vaciado de un flujo. Salida

hex Formato de datos númericos en Entrada/ Salida

hexadecimal.

oct Formato de datos númericos en Entrada/ Salida

octal.

resetiosflag(long Desactiva los indicadores Entrada/Salida

f) especificados en f.

setbase(int Establece el número de la base a Salida

base) base.

setfill(int c) Establece el caracter de relleno a c. Entrada/Salida

setiosflag(long Activa los indicadores especificados Entrada/Salida

f) en f.

setprecision(int Establece el número de dígitos a Entrada/Salida

p) mostrar después del punto
decimal.

setw(int w) Establece la anchura de campo a Entrada/Salida

w.

ws Hace que se ignoren los espacios Entrada

 en blanco iniciales.

Para acceder a esos manipuladores, se debe incluir el archivo

iomanip.h en el programa. Se puede usar un manipulador como parte
de la expresión de E/S.
He aquí un ejemplo de programa que se usa para cambiar el formato
de la salida:
#include <iostream.h>
#include <iomanip.h>
main(void)
{
cout << setprecision(2) << 1000.243 << endl;
cout << setw(30) << "Hola esto es Turbo C++.";
return 0;
}
El programa produce esta salida:
1000.24
Hola esto es Turbo C++.
Estructura de Bloques <Subir>

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).
Arreglos o Arrays <Subir>

En C o C++ existe una fuerte relación entre apuntadores y arreglos.

Tan fuerte que deben discutirse simultáneamente. Cualquier operación
que se pueda llevar a cabo por indexación de un arreglo, también puede
realizarse con apuntadores (punteros). La versión con apuntadores será
por lo general más rápida, pero más difícil de entender para los no
iniciados en este lenguaje.
Por lo pronto veremos, el formato para la declaración de arreglos es:
especificador-categoría-almacenamiento especificador-de-tipo
tipo_de_arreglo nombre[tamaño];
Podemos inicializar un arreglo de la siguiente manera:
Arreglo de caracteres:
char mensaje[20];
o bien
char mensaje[]={'H','o','l','a',' ','c','o','m','o','
','e','s','t','a','n','\0'};

o bien
char mensaje[]="Hola como están";
Si el arreglo debe definirse sin valores iniciales, se debe especificar la
primera definición, sino la tercera es la mas recomendable sobre la
segunda.
Arreglo de enteros:
int nument[10];
int nument[]={0,1,2,3,4,5,6,7,8,9};
define un arreglo nument de tamaño 10, esto es, un bloque de 10
objetos consecutivos llamados nument[0],nument[1],...,nument[9].
De esta forma pueden declarse arreglos de cualquier tipo.
Arreglos Multidimensionales.—
C++ admite arreglos multidimensionales. La forma mas simple de un
arreglo multidimensional es el arreglo bidimensional. Esencialmente, un
arreglo bidimensional es un arreglo de arreglos unidimensionales. Su
declaración es la siguiente:
esp.-categ.-almacen. espec.-de-tipo tipo_de_arreglo
nombre[tamaño_fila] [tamaño_columna];
Por lo tanto para definir un arreglo num de enteros bidimensional de
tamaño 10,20 se definirá:
int num[10][20];
Para acceder a la posición 3,2 se hace:
num[2][1]=20;
La inicialización es de la siguiente manera:
int num[4][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12},
{13,14,15,16}};
Funciones <Subir>

En el lenguaje C++ una función proporciona una forma conveniente

de encapsular algunos cálculos, que se pueden emplear después sin
preocuparse de su implantación. Con funciones diseñadas
adecuadamente, es posible ignorar como se realiza un trabajo; es
suficiente saber qué hace. El lenguaje C++ hace que el uso de las
funciones sea fácil, conveniente y eficiente.
Una definición de función tiene la siguiente forma:
tipo_de_retorno
nombre_de_funcion(declaración_de_parámetros_formales)
{
declaraciones;
proposiciones;
}
Para esto veremos un ejemplo:
1. /******************Archivo
potencia.cpp**********************/
2. #include <iostream.h>
3.
4. long double potencia(int x, int y); // prototipo de la
función
5.
6. main(void) // función que no recibe argumentos
7. {
8. int i; // variable i local a la función
9. for(i=0;i < 20;++i)
10. cout << potencia(2,i)<< potencia(3,i);
11. return 0;
12. }
13.
14. long double potencia(int x, int y) //Retorna un valor
long double
 15. {
16. long double i; // variable i local a la función
17. for(i=1;y > 0;--y) // ciclo for con distintas
variables
18. i*=x; // operador i=i*x;
19. return i;
20. }

Comencemos el análisis de este programa:

La segunda linea, ya todos la conocen, es uno de las primeras
instrucciones de lo que se llama preprocesamiento, y es el primer paso
antes de la compilación. En particular #include indica que se debe incluir
información acerca de algunas funciones que se utilizaran en el
programa, como ya se sabe. Pero lo que mas nos interesa es el
contenido en concreto de los archivos de encabezamiento (biblioteca de
funciones, librería, etc.) , header de allí la extensión .h . Estas librería
contienen lo que se llama en C++ el prototipo de la función, que vendría
a ser algo así como su declaración explícita. Por lo tanto todas las
funciones, salvo main, tienen un prototipo definido en algún lugar, y si
no lo tiene, por ejemplo si ignoramos potencia() con dos barras
consecutivas:
3. // long double potencia(int x, int y);
El compilador indicará el siguiente error:
1. Compiling ..\MIO\POTENCIA.CPP:
2. Error ..\MIO\POTENCIA.CPP 10: Function 'potencia' should have a
prototype
3. Warning ..\MIO\POTENCIA.CPP 10: Call to function 'potencia()'
with no prototype
4. Warning ..\MIO\POTENCIA.CPP 10: Call to function 'potencia()'
with no prototype
1. Compilando ..\MIO\POTENCIA.CPP comienzo de la compilación
2. Error ..\MIO\POTENCIA.CPP linea 10: Función 'potencia' debe
tener un prototipo.
3. Advertencia.. \MIO\POTENCIA.CPP 10: Llamada a la función
'potencia()' sin un prototipo.
4. Advertencia.. \MIO\POTENCIA.CPP 10: Llamada a la función
'potencia()' sin un prototipo.
La linea 3 y 4 se debe a que potencia() fue invocada dos veces.
Por lo tanto declarar el prototipo de la función a utilizar es muy
importante e imprescindible, puesto que no compilaremos el programa
adecuadamente. La porción de código que nos interesa más es la que va
del numero de linea 14 a línea 20. Estas líneas contienen una función
cuyo prototipo fue declarado explícitamente en la línea 3. Esta función
retorna un valor long double y recibe como parámetros dos valores
enteros. El valor de retorno, y el control a la función que llama o el
sistema operativo en el caso de main, es reintegrado a través de la
sentencia return en las líneas 11 y 18. Return puede tener a
continuación cualquier expresión de cualquier tipo, si es necesario el
valor se convertirá al tipo de retorno.
Argumentos
En C++, todos los argumentos de una función se pasan por valor.
Esto significa que la función que se invoca recibe los valores de sus
argumentos en variables temporales y no en las originales. Esto es, la
función que se invoca no puede alterar directamente una variable de la
función que hace la llamada; solo puede modificar su copia privada y
local.
Cuando es necesario, es posible hacer que una función modifique una
variable dentro de una rutina invocada. La función que llama debe
proporcionar la dirección de la variable que se cambiará (técnicamente
un apuntador a la variable) y la función que se invoca debe declarar que
el parámetro sea un apuntador y tengo acceso a la variable
indirectamente a través de él.
Veamos algunos ejemplos:
Supongamos que estamos haciendo un ordenamiento de elementos
de un arreglo de enteros. Dicho ordenamiento requiere en algún
momento, el intercambio entre dos elementos de dicho arreglo, y para
realizar tal tarea, recurrimos a una función:
void intercambio(int x, int y)
{
int temp;
temp=x;
x=y;
y=temp;
}
Y el problema fundamental aquí es que el intercambio de variables no
afecta a las variables enviadas como argumentos sino solo a sus copias
privadas y locales. Por el contrario la siguiente función realiza el trabajo
que deseamos obtener como resultado:
void intercambio(int &x, int &y)
{
int temp;
 temp=x;
x=y;
y=temp;
}
x y y son apuntadores implícitos a enteros y por lo tanto cumplen con
el requisito de paso de valores por referencia, requisito fundamental
para que una función modifique el contenido de la variable que se pasa
como argumentos.
La historia es diferente a la hora de hacer pasajes de valores del tipo
arrays o arreglos como argumentos. Cuando el nombre de un arreglo es
pasado como argumento, el valor que se pasa a la función es la
localización o la dirección del principio del arreglo -no hay copia de los
elementos del arreglo. Al colocarle subíndices a este valor, la función
puede tener acceso y alterar cualquier elemento del arreglo por
ejemplo:
A continuación presentamos un programa que realiza una carga de
datos en dos matrices, y luego llama a una función para realizar la suma
de sus elementos y mostrar los resultados en pantalla. De esta manera
ilustramos el pasaje de parámetros tipo arrays a funciones.
/
*************************************************************
***********
CALCULA LA SUMA DE DOS MATRICES DEL MISMO TAMAÑO
*************************************************************
***********/
#include <iostream.h>
#include <conio.h>
// prototipo de la función sumar
void sumar(long double a[][50],long double b[][50],int m,int n);
void main(void) // función que no retorna valor void, "nada"
{
long double a[50][50],b[50][50];
int m,n,i,j;
clrscr(); //Limpia la pantalla, prototipo definido en conio.h
cout << "Ingresar Cantidad filas=> "; // prototipo definido en
iostream.h
cin >> m; // prototipo definido en iostream.h
cout << "Ingresar Cantidad Columnas => ";
cin >> n;
/* Leer datos de la matriz del teclado */
for(i = 1;i <= m;i++)
for(j = 1;j <= n;j++)
{
cout << "A[" << i << "," << j << "] => ";
 cin>> a[i][j];
cout << "B[" << i << "," << j << "] => ";
cin >> b[i][j];
}
sumar(a,b,m,n); // paso de valores matrices a y b, enteros m y n
// Resultado de sumar A + B
cout << "\nMatriz A modificada \n\r";
cout << "A[1,1] =" << a[1][1];
getch(); // Espera por una tecla; prototipo definido en conio.h
}
void sumar(long double a[][50], long double b[][50],int m,int n)
{
int i,j;
// Resultado de sumar A + B
cout << "\nA + B = \n\r";
for(i = 1;i <= m;i++)
for(j = 1;j <= n;j++)
cout << "C[" << i << "," << j << "]=" << a[i][j] + b[i][j]<<
"\n";
a[1][1]=3.141592;
}

El tamaño de las filas no es necesario, pero el compilador necesita

saber cual es el tamaño de la segunda dimensión o tamaño de las
columnas es por ello que se debe informar al compilador acerca de cuan
grande es la segunda dimensión.
Por otro lado si lo que se pasa como argumento a una función es un
elemento determinado del array, este elemento es tratado como una
variable común por lo tanto deberemos pasar su localización en
memoria a través de un puntero como lo hacemos para las llamadas a
referencia con variables.
Con el siguiente ejemplo, daremos una explicación de como es
posible pasar como argumentos a funciones, arrays unidimensionales de
tres formas distintas:
#include <iostream.h>
void mostrar(int num[10]);
main(void)
{
int t[10],i;
for(i=0;i < 10;++i) t[i]=i;
mostrar(t);
return 0;
}
/*********método 1***********/
void mostrar(int num[10])
{
int i;
 for(i=0;i < 10;i++) cout << num[i];
}
/*********método 2***********/
void mostrar(int num[]) //reemplazamos el prototipo y la función
{
int i;
for(i=0;i < 10;i++) cout << num[i];
}
/*********método 3***********/
void mostrar(int &num) //reemplazamos el prototipo y la funcion
{
int i;
for(i=0;i < 10;i++) cout << num[i];
}

Finalmente el tipo de arreglos más comunes en C++, son los arreglos

de caracteres. Los arreglos de caracteres son muy usuales
conjuntamente con los punteros a caracteres (strings) dado que en C++
no existe el tipo string definido como tipo de dato.
#include <stdio.h>
#include <iostream.h>
#include <ctype.h>
#include <conio.h>
void main(void)
{
int b,c,dd,mm,aa;
char nombre[30],sal='N'; // vector de 30 caracteres
for(b=0;(b <= 4) && (sal != 'S');b++) // flexibilidad del ciclo
for
{
clrscr(); // LIMPIAR LA PANTALLA
fflush(stdin); // VACIAR EL BUFFER DE ENTRADA DE GETS() PARA
NUEVOS DATOS
/*******INGRESOS DE DATOS, LEER UN STRING DESDE EL
TECLADO*********/
cout << "\nHola, ...\nComo te llamas? : "; // \n salto de
linea
gets(nombre);
cout << "\t\t" << nombre <<"\n"; //\t tabulación
//LEER Y MOSTRAR LA FECHA EN CUALQUIER FORMATO DD/MM/AA, DD-
MM-AA, ETC..
cout << "Ingresar fecha : ";
cin >> dd >> c >> mm >> c >> aa;
cout << "\t\t" << dd << c << mm << c << aa << "\n";
// GETCHE() LEE DE A UN CARACTER CON ECO.
cout << "Salir S o N ?: ";
sal=toupper(getche()); // toupper(char c) convierte a
mayúsculas.
}
}
 Para finalizar daremos a continuación una lista de las librerías
asociadas a turbo C y cuales funciones soportan o definen su prototipo.
Archivos de cabecera de Turbo C++.

Nombre del Funciones relacionadas

archivo

alloc.h Asignación dinámica de memoria.

assert.h Define assert().

bios.h Funciones de interfaz con el BIOS.

conio.h Funciones de entrada/salida directa por

consola.

complex.h Funciones de manipulación de números

complejos

ctype.h Funciones relacionadas con caracteres.

dir.h Funciones relacionadas con directorios.

dos.h Funciones de interfaz con el DOS.

errno.h Define varios códigos de error.

fcntl.h Define varias constantes utilizadas por el

sistema de archivos tipo UNIX.

float.h Define los límites de reales en coma flotante.

graphics.h Funciones relacionadas con gráficos.

io.h Funciones de entrada/salida.

iostream.h Funciones de entrada/salida.

iomanip.h Funciones de manipulación de formatos de

salida o entrada.

limits.h Define varios límites de enteros.

locale.h Funciones específicas de países.

math.h Funciones matemáticas.

mem.h Funciones de manipulación de memoria.

process.h Funciones de control de procesos.

 setjmp.h Requerido por setjmp() y longjmp().

share.h Funciones de soporte a la compartición de

archivos.

signal.h Soporte para signal() y raise().

stdargs.h Soporte para argumentos de longitud variable.

stddef.h Define tipos y macros estándar.

stdio.h Funciones de entrada/salida estándar.

stdlib.h Funciones variadas.

string.h Funciones relacionadas con archivos.

sys/stat.h Constantes relacionadas con archivos.

sys/timeb.h Soporta la función ftime().

sys/types.h Define time_t, usado por las funciones de hora.

time.h Funciones de hora y fecha.

values.h Varias constantes dependientes de la

implantación.

A continuación describimos algunas de las funciones más importantes

y sus respectivas librerías que definen sus prototipos.
prototipos definido en conio.h
int getch(void); int getche(void);
Ambas funciones leen un caracter desde el teclado y retornan como
un entero el valor de la tecla pulsada, getche() muestra en pantalla el
caracter leido, getch() no.
int putch(int c);
Esta función muestra un caracter en la pantalla y retorna como un
entero el valor del caracter impreso.
En esta librería están definidas las funciones de manipulación de
pantallas de texto. A continuación el listado de las mas importantes:

void clrscr(void); Limpia la ventana activa.

void clreol(void); Limpia desde la posición del cursor

hasta el final de la línea de la ventana
 activa.

void delline(void); Borra la linea en donde esta ubicado el

cursor.

void gotoxy(int x, int Ubica el cursor en las coordenadas

y); establecidas.

void insline(void); Inserta una linea a partir de la posición

actual del cursor.

void textattr(int Define el atributo de texto de la

atributo); ventana activa, color de frente y de
fondo.

void textcolor(int Define el color de frente del la ventana

color); activa.

void Define el color de fondo de la ventana

textbackground(int activa.
color);

void highvideo(void); Muestra el texto en alta intensidad.

void lowvideo(void); Muestra el texto en baja intensidad.

void normvideo(void); Muestra el texto en la intensidad

original.

int wherex(void); Devuelve la coordenada x del cursor.

int wherey(void); Devuelve la coordenada y del cursor.

void textmode(int Establece el modo de video.

modo);

Existen mas funciones, y cada una de ellas está explicada y

comentada con un ejemplo en la ayuda en linea del compilador Turbo
C++.
Describiremos ahora las mas importantes funciones matemáticas
definidas en math.h y algunas constantes predefinidas:
long labs (long x);
Calcula el valor absoluto de un argumento long y retorna un valor
long.
int abs (int x);
Calcula el valor absoluto de un argumento int y retorna un valor int.
double acos (double x);
Calcula el coseno de un argumento double y retorna un valor double.
double atof (const char *s);
Convierte un string de caracteres numéricos y retorna un valor
double.
double hypot (double x,double y);
Calcula la hipotenusa de un triangulo, recibe como argumentos los
lados a y b retorna un valor double.
double poly (double x,int degree,double *coeffs);
Calcula el valor de una funcion polinomica cuyo orden, valor para
calculo y coeficientes son pasados como argumentos double. Los
coeficientes deben pasarse como un array de valores.
double pow10 (int p);
Calcula el valor de una potencia en base 10 elevado a un exponente
int y retorna un valor double.
double asin (double x);
Calcula el arco seno de un argumento double y retorna un valor
double.
double atan (double x);
Calcula el arco tangente de un argumento int y retorna un valor
double.
double atan2 (double y,double x);
Calcula el arco tangente del cociente de dos argumentos double y/x y
retorna un valor double.
double ceil (double x);
Redondea un valor double x a su entero superior mas proximo y
retorna dicho entero como un valor double.
double cos (double x);
Calcula el coseno de un argumento double y retorna un valor double.
double cosh (double x);
Calcula el coseno hiperbólico de un argumento double y retorna un
valor double.
double exp (double x);
Calcula la potencia de un valor double x en base e y retorna un valor
double.
double fabs (double x);
Calcula el valor absoluto de un argumento double y retorna un valor
double.
double floor (double x);
Trunca un argumento double a su entero inferior mas proximo y
retorna un valor double.
double fmod (double x,double y);
Calcula el modulo de un argumento double x divido por un argumento
y, y retorna el resto como un valor double.
double frexp (double x,int *exponent);
Descompone el numero x en una mantisa de rango entre 0.5 y 1, sin
llegar a 1, y en un exponente entero tal que x=mantisa*2exp. Devuelve
la mantisa y el exponente se guarda en y.
double ldexp (double x,int exponent);
Calcula el valor de la función x*2exp y retorna el valor calculado como
un double.
double log (double x);
Calcula el logaritmo natural de un argumento double y retorna un
valor double.
double log10 (double x);
Calcula el logaritmo en base 10 de un argumento double y retorna un
valor double.
double modf (double x,double *ipart);
Descompone el valor x en su parte entera, lo coloca en ipart y
retorna como un valor double el resto fraccionario.
double pow (double x,double y);
Calcula la potencia de un valor double x elevado a un valor double y
retorna un valor double.
double sin (double x);
Calcula el seno argumento double y retorna un valor double.
double sinh (double x);
Calcula el seno hiperbólico de un argumento double y retorna un
valor double.
double sqrt (double x);
Calcula la raíz cuadrada de un argumento double y retorna un valor
double.
double tan (double x);
Calcula la tangente de un argumento double y retorna un valor
double.
double tanh (double x);
Calcula la tangente hiperbólica de un argumento double y retorna un
valor double.
Las siguientes funciones son las mismas que las anteriormente
explicadas, son la version para datos long double en el caso de requerir
mayor precisión de calculo.
long double acosl (long double x);
long double asinl (long double x);
long double atan2l (long double x,long double y);
long double atanl (long double x);
long double ceill (long double x);
long double coshl (long double x);
long double cosl (long double x);
long double expl (long double x);
long double fabsl (long double x);
long double floorl (long double x);
long double fmodl (long double x, long double y);
long double frexpl (long double x, int *exponent);
long double ldexpl (long double x, int exponent);
long double log10l (long double x);
long double logl (long double x);
long double modfl (long double x,long double *ipart);
long double powl (long double x,long double y);
long double sinhl (long double x);
long double sinl (long double x);
long double sqrtl (long double x);
long double tanhl (long double x);
long double tanl (long double x);
long double atold (const char *s);
long double hypotl (long double x, long double y);
long double polyl (long double x, int degree, long double
*coeffs);
long double pow10l (int p);
/* Constantes redondeadas para 21 decimales. */
#define M_E 2.71828182845904523536
#define M_LOG2E 1.44269504088896340736
#define M_LOG10E 0.434294481903251827651
#define M_LN2 0.693147180559945309417
#define M_LN10 2.30258509299404568402
#define M_PI 3.14159265358979323846
#define M_PI_2 1.57079632679489661923
#define M_PI_4 0.785398163397448309616
#define M_1_PI 0.318309886183790671538
#define M_2_PI 0.636619772367581343076
#define M_1_SQRTPI 0.564189583547756286948
#define M_2_SQRTPI 1.12837916709551257390
#define M_SQRT2 1.41421356237309504880
#define M_SQRT_2 0.707106781186547524401
Consideraciones <Subir>

Para mas referencias a las funciones disponibles consultar la ayuda

de Turbo C++.
Para mas bibliografía, consultar cualquier libro de Programación C+
+ de cualquier autor.