Está en la página 1de 34

Turbo C / C++

Introducin
Variables y Expresiones Aritmticas
Tipos, operadores y expresiones
Control de flujos
Operaciones de Entrada y Salida
Estructura de Bloques
Arreglos
Funciones
Consideraciones

Introduccin
El lenguaje de programacin que veremos a continuacin es el

C++

Lenguaje
. Este lenguaje pertenece a la clase de lenguajes
comunmente llamados hbridos, pues soportan dos filosofas
distintas de programacin: la primera la que veremos a lo largo
de este curso: la programacin estructurada; la segunda de estas
filosofas es la programacin orientada a objetos, POO.
El lenguaje C++ es algo as como una versin mejorada del lenguaje
C, con lo cual cualquier programa escrito en el lenguaje C tambin es un
programa C++. El Lenguaje C++ es un lenguaje de programacin de
propsito general, es decir, es posible escribir cualquier tipo de
programas con l, incluyendo programas especficos de tipo
matemticos.
Comencemos.
La nica forma de aprender un nuevo lenguaje de programacin es
escribiendo algunos programas en l y describirlo a partir de estos.
Imprimir las palabras
Mundo, esto es "C++".

=>

Hola

#include <iostream.h>
main()
{
cout
}

<<

"Hola

Mundo,

esto

es

\"C++\"\n";

Un programa en C++ cualquiera sea su tamao, consta de funciones


y variables. Una funcin contiene proposiciones que especifican las
operaciones de clculo que se van a realizar, y a las variables que
almacenan los valores utilizados durante los clculos. Nuestro ejemplo
es una funcin llamada main. Normalmente se tiene la libertad de dar
cualquier nombre que se desee a una funcin, pero main es especial, el
programa siempre debe tener un main, porque el programa comienza a
ejecutarse a partir de l.
La primera lnea:
#include <iostream.h>

Indica al compilador que incluya informacin acerca de algunas de las


funciones que luego se usaran en el programa y que estn definidas en
esta
biblioteca
o
comnmente
llamada
"librera".
Un mtodo para comunicar datos entre las funciones es que la
funcin que llama, proporciona una lista de valores, llamados
argumentos, a la funcin a la que se est invocando. Los parntesis que
estn despus del nombre de la funcin encierran a la lista de
argumentos. En este ejemplo, main est definido para ser una funcin
que no espera argumentos, lo cual esta indicado por la lista vaca (). Las
proposiciones de una funcin estn 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 librera
<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 funcin que cumple aqu es evitar que se
malinterprete un final de string (cadena de caracteres), \n es para que
se imprima una nueva lnea luego de imprimir el o los argumento/s que
contiene. Si se omite \n, no habr avance de lnea puesto cout no lo
proporciona.
Nuestro programa tambin se hubiera podido escribir as:
#include <iostream.h>
main()
{
cout << "Hola ";
cout << "Mundo ";
cout << "Esto es \"C++\"\n";

Variables y Expresiones Aritmticas


El siguiente Programa utiliza la formula C=(5/9)x(F-32) para
imprimir una tabla de temperaturas Fahrenheit y sus equivalentes en
grados centgrados 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 mnima de la tabla
maxima=300; // temperatura mxima de la tabla
paso=20; // tamao del incremento
while(fahr <= maxima)
{
celsius=5*(fahr-32)/9;
cout << fahr << "\t" << celsius;
fahr=fahr+paso;
}
}

Las dos lneas encerradas entre /* y */ o tambin los caracteres


despus de // son comentarios. En C++ se deben declarar todas las
variables antes de su uso, generalmente al principio de la funcin y
antes de cualquier proposicin ejecutable. Una declaracin 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 tabulacin (\t) entre ellos. El ciclo while
funciona de la siguiente manera: se prueba la condicin entre parntesis
(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 razn de multiplicar por 5 y despus dividir por 9 es que en C++


como en la mayora de los otros lenguajes, la divisin de enteros trunca
el resultado: cualquier parte fraccionaria se descarta puesto que 5 y 9
son enteros, 5/9 sera truncado a 0 y todas las temperaturas se
reportaran
como
0.

Existe un problema aqu, debido a que se ha utilizado aritmtica 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
reportara. Para obtener soluciones mas precisas se debe utilizar
aritmtica 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 mnima de la tabla
maxima=300; // Temperatura mxima de la tabla
paso=20; // Tamao 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 eliminacin de
la mayora de las variables; solo permanece fahr y la hemos hecho
entera (int).
La proposicin for es un ciclo, una forma generalizada del while.
Dentro de los parntesis existen tres secciones separadas por punto y
coma. La primera vez, la inicializacin se ejecuta una vez, antes de
entrar propiamente al ciclo. La segunda seccin es la condicin que
controla el ciclo: fahr <= 300;. Esta condicin se evala si es

verdadera, el cuerpo del ciclo (en este caso un simple cout) se ejecuta.
Despus el incremento de avance: fahr=fahr+20; se ejecuta y la
condicin se vuelve a evaluar. El ciclo termina si la condicin es falsa. Tal
como con el while, el cuerpo del ciclo puede ser una proposicin sencilla
o un grupo de proposiciones encerradas entre llaves. La inicializacin, la
condicin y el incremento pueden ser cualquier expresin. La eleccin
entre el while y el for es arbitraria y se basa en aquello que parezca ms
claro. El for es por lo general apropiado para ciclos en los que la
inicializacin y el incremento son expresiones sencillas y lgicamente
relacionadas, puesto que es mas compacto que el while y mantiene
reunidas en un lugar a las proposiciones que controlan el ciclo.
Una observacin final antes de dejar el tema de conversiones de
temperaturas. Es una mala prctica poner "nmeros mgicos" como 300
y 20 en un programa, ya que proporciona muy poca informacin a quien
tenga que leer el programa y son difciles de modificar en forma
sistemtica.
Una lnea #define define un nombre simblico o constante simblica,
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 // TAMAO 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);

}
*Ntese que no hay punto y coma despus de la lnea #define.
Todo lo visto, debe servir para orientarlos en la filosofa del lenguaje,
en el estilo y estructuracin. Ahora dejaremos un poco estas
ejemplificaciones y seremos ms concretos en los aspectos de este
lenguaje.

Tipos, Operadores y Expresiones


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 tambin es vlido, pero
no es aconsejable que una variable comience con tal caracter, dado que la mayora de
las rutinas de las libreras anexas usan tal caracter como caracterstica en sus
nombres.
Las letras maysculas y minsculas son distintas, de tal manera x y X son dos
nombres diferentes. La prctica tradicional y mas aconsejable en C++ es usar letras
minsculas para nombres de variables y todo en maysculas para nombres de
constantes.
Las palabras claves o reservadas, no se deben utilizar como variables. Todas deben
escribirse con minsculas.

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 bsicos de datos, declaraciones.


Las declaraciones especifican la interpretacin dada a cada identificador
(variable o constante). El formato sera:
especificador-categora-almacenamiento
especificador-de-tipo tipo lista de declaraciones;
Especificadores de categora de almacenamiento.
auto
register
static
extern

Existen dos categoras de almacenamiento: la automtica y la


esttica. Los objetos automticos son locales a un bloque y son
descartados al salir del bloque. Las declaraciones dentro de un bloque
crean objetos automticos si no se emplea el especificador auto.
1. Los objetos declarados como register son automticos y sugiere que se
harn acceso frecuente a los objetos declarados y se almacenan (si es
posible) en los registros rpidos de la mquina. Para los objetos
declarados como auto no es necesario especificar esta condicion puesto
que cada variable dentro de un bloque al que pertenece es automtica,
es decir es su espacio es creado al entrar al bloque.
2. Los objetos estticos 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 estticos.
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

void

------

Tiene tres tipos de usos que luego se


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 int

16 bits

0 a 65.535

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 funcin significa que
es una funcin que no retorna valor alguno.
2. Cuando se declaran los argumentos de una funcin, colocar void entre
los parntesis, indique de manera explcita que la funcin no recibe
valores de argumento.
3. Como declarador para punteros genricos.

Las constantes.

Existen varias clases de constantes, a saber:


1. constantes enteras
2. constantes de caracteres
3. constantes de punto flotante
4. constantes de enumeracin
5. constantes simblicas

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

unsigned long

12345678 ul UL

0123456ul UL

0x1aul UL 0X1Aul
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 apstrofe: A, x, h , etc.
Tambin pertenecen a este tipo las denominadas
"secuencias de escape", las constantes de caracter, estn
representadas de igual forma con la salvedad de que
despus del apstrofe le sigue una barra invertida, como:

\a caracter de alarma (beep)

\\ diagonal invertida

\b retroceso

\? interrogacin

\f avance de hoja

\ apstrofe

\n avance de linea

\" comillas

\r regreso de carro

\000 nmero octal

\t tabulador horizontal

\xhh nmero 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 travs de constantes
de enumeracin. Las constantes de enumeracin se definen del
siguiente modo:

enum boolean {FALSE,TRUE};


La primera constante de enumeracin dentro de las llaves tiene el
valor 0 la siguiente el 1. Si no se les asignan valores explcitos en
orden ascendente, la inicializacin 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 simblicas 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 tambin pueden ser declaradas con el
modificador de acceso const.
const
const
const
const
const

int ENTERO=-237;
float PI=3.141592;
double PI_D=3.1415926536;
long double E=2.71828182845904523536
char msg[]="Hola mundo, esto es C++";

Operadores.
1. Aritmticos.
Los operadores aritmticos son:

* , / , % (operador mdulo para enteros)


+,en orden de precedencia.
2. Lgicos y de relacin.
Los operadores de relacin son:

> , >= , < , <=


Todos ellos tienen la misma precedencia.

3. Bajo ellos en precedencia estn los operadores de igualdad:


== , !=
Los
operadores aritmticos
tienen
mayor
precedencia que los operadores de relacin, una
expresin como:
i < lim-1 se toma como i < (lim-1) como se
esperara.
4. Los operadores lgicos 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 disminucin -- 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 parntesis los efectos del
operador son incrementar o decrementar a las variables antes de
que su valor se utilice, para el segundo parntesis es incrementar
o decrementar las variables despues de utilizada la variable.
Operadores
Si

expr1

de

asignacin

expr2

son

dos

expresiones.

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 cdigo, asigna a la variable y el valor 100.

Control de flujos
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 especficos en sus
declaraciones.
Proposiciones y bloques.
Una expresin como x = 0 i++ o cout << ... se convierte en una
proposicin 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 proposicin. Las
llaves { } se emplean para agrupar declaraciones y proposiciones dentro

de una proposicin compuesta o bloque. No hay punto y coma despus


de la llave } de cierre de un bloque.
If-else.
Formalmente la sintaxis es:
if(expresin)
proposicin1;
else
proposicin2;

Ejemplo:

if(a<b)
z=a;
[else
z =b;]

Los puntos y comas en proposicion1 y proposicin2 dan la


aclaracin mencionada. Los corchetes en la clusula else indica
que sta es opcional. Debido a esto, existe una ambigedad
cuando un else se omite de una sentencia if anidada.
Por ejemplo:
if(n > 0)
if(a < b)
z = a;
else
z = b;

El else va con el if mas


interno como se muestra
en el sangrado. Si esto
no es lo que se desea, se
deben utilizar las llaves
para forzar la asociacin
correcta o deseada.

if(n >0) {
if(a < b)
z = a;
}
else
z = b;

Else-if.
La construccin es:
if(expresin)
proposicin1;
else if(expresin)
proposicin2;
else if(expresin)
proposicin3;
else
proposicin4;

Esta secuencia de proposiciones if es la forma


general de escribir una decisin mltiple. Las
expresiones se evalan en orden, si cualquier
expresin es verdadera, la proposicin
asociada con ella se ejecuta, y esto termina
toda la cadena. Como siempre, el cdigo para
cada proposicin es una proposicin simple o
un grupo dentro de llaves.

La parte del ultimo else maneja el


caso "ninguna de las anteriores", esta
tambin puede omitirse

Switch.
La proposicin switch es una decisin mltiple que prueba si una
expresin coincide con uno de un nmero de valores constantes (casos)
enteros, y traslada el control adecuadamente:
switch(expresin) {
case exp-constante :
proposicin1;
case exp-constante :
proposicin2;
case exp-constante :
proposicin3;
default : proposicin4;
}

Dentro
de
cada
case
y
como
proposicin final, debe ir la proposicin
break, para que la seleccin culmine
con la ocurrencia del caso nico que se
ha cumplido. La clausula default es
opcional

Ciclos - whiles - for - do-while.


Ya hemos visto anteriormente los ciclos for y while.
while(expresin)
proposicin;
La proposicin for:
for(expr1; expr2; expr3)
proposicin;
es equivalente a:
expr1;
while(expr2) {
proposicin;
expr3;
}
El usar while o for es principalmente cuestin de preferencia personal.
El for se prefiere cuando existe inicializacin simple e incrementos,
puesto que mantiene las proposiciones de control del ciclo juntas y
visible al principio del mismo.
Tanto el ndice como el lmite 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 razn. Debido a que los
componentes de for son expresiones arbitrarias, sus ciclos no estn
restringidos a progresiones aritmticas.

Los ciclos while y for verifican al principio la condicin de trmino. En


contraste, el tercer ciclo en C++, el do-while, prueba al final despus de
realizar cada paso a travs del cuerpo del ciclo, el cual se ejecuta
siempre por lo menos una vez.
La sintaxis del do es:
do
proposicin;
while(expresin);
El ciclo do-while en C++ es igual que el while pero la salvedad est
en que la verificacin de la condicin se hace al final. Luego si el ciclo va
acompaado de varias proposiciones deben encerrarse entre llaves,
despus 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
combinacin de un salto de carro y salto de lnea. En C++, el smbolo
<< tiene un cometido ms amplio sigue siendo el operador de
desplazamiento a la izquierda, pero cuando se usa como se muestra en
este ejemplo, tambin es un operador de salida. La palabra cout es un
identificador que esta asociado a la pantalla. Al igual que C, C++
permite la redireccin de la E/S, pero por lo que respecta a esta
explicacin, asumiremos que cout se refiere a la pantalla. Se puede usar
cout y el smbolo << para mostrar cualquiera de los tipos de datos
incorporados o predefinidos, adems de las cadenas de caracteres.
Si nuestro programa requiere que ingresemos algo desde el teclado,
procedemos por ejemplo:
cin >> i;
El nmero se lee a travs 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 bsicos de datos
o cadenas.
Uso de los manipuladores.
El sistema de E/S de C++ incluye una forma de alterar los
parmetros 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 estndar se muestran a continuacin:

Manipulador

Propsito

Entrada/Salida

dec

Formato de datos numricos en


decimal.

Entrada/Salida

endl

Salida de un caracter de nueva


linea y vaciado del flujo.

Salida

ends

Salida de un caracter nulo.

Salida

flush

Vaciado de un flujo.

Salida

hex

Formato de datos nmericos en


hexadecimal.

Entrada/ Salida

oct

Formato de datos nmericos en


octal.

Entrada/ Salida

resetiosflag(long Desactiva los indicadores


f)
especificados en f.

Entrada/Salida

setbase(int
base)

Establece el nmero de la base a


base.

Salida

setfill(int c)

Establece el caracter de relleno a c. Entrada/Salida

setiosflag(long
f)

Activa los indicadores especificados Entrada/Salida


en f.

setprecision(int Establece el nmero de dgitos a


Entrada/Salida
p)
mostrar despus del punto decimal.
setw(int w)

Establece la anchura de campo a


w.

Entrada/Salida

ws

Hace que se ignoren los espacios


en blanco iniciales.

Entrada

Para acceder a esos manipuladores, se debe incluir el archivo


iomanip.h en el programa. Se puede usar un manipulador como parte de
la expresin 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
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 inicializacin) pueden seguir a la llave
izquierda que indica cualquier proposicin compuesta, no solo la que
inicia a una funcin. Las variables pueden declaradas de esta manera,
cualquier nombre idntico de variables de bloques ms 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.

Inicializacin
La inicializacin de una variable puede llevarse a cabo en el momento
de su declaracin. Para ello se procede a declararla y luego el signo igual
y los valores de inicializacin, por ejemplo:
int i=0;
char letra='A';
double sala=200.39;
En ausencia de declaracin explcita, se garantiza que las variables
externas y estticas se inicializan en 0; las variables automticas y tipo
registro tienen valores iniciales indefinidos (basura).

Arreglos o Arrays
En C o C++ existe una fuerte relacin entre apuntadores y arreglos.
Tan fuerte que deben discutirse simultneamente. Cualquier operacin
que se pueda llevar a cabo por indexacin de un arreglo, tambin puede
realizarse con apuntadores (punteros). La versin con apuntadores ser
por lo general ms rpida, pero ms difcil de entender para los no
iniciados en este lenguaje.
Por lo pronto veremos, el formato para la declaracin de arreglos es:
especificador-categora-almacenamiento especificador-de-tipo
tipo_de_arreglo nombre[tamao];

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 estn";

Si el arreglo debe definirse sin valores iniciales, se debe especificar la


primera definicin, 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 tamao 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
declaracin es la siguiente:
esp.-categ.-almacen.
espec.-de-tipo
nombre[tamao_fila] [tamao_columna];

tipo_de_arreglo

Por lo tanto para definir un arreglo num de enteros bidimensional de


tamao 10,20 se definir:
int num[10][20];
Para acceder a la posicin 3,2 se hace:
num[2][1]=20;
La inicializacin 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
En el lenguaje C++ una funcin proporciona una forma conveniente
de encapsular algunos clculos, que se pueden emplear despus sin
preocuparse
de
su
implantacin.
Con
funciones
diseadas
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 fcil, conveniente y eficiente.
Una definicin de funcin tiene la siguiente forma:

tipo_de_retorno
nombre_de_funcion(declaracin_de_parmetros_formales)
{
declaraciones;
proposiciones;
}

Para esto veremos un ejemplo:


1.
2.

/******************Archivo
potencia.cpp**********************/
#include <iostream.h>

3.
4.

long double potencia(int x, int y); // prototipo de


la funcin

5.
6.

main(void) // funcin que no recibe argumentos

7.

8.

int i; // variable i local a la funcin

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


funcin

17.

for(i=1;y > 0;--y) // ciclo for con


distintas variables

18.

i*=x; // operador i=i*x;

19.
20.

return i;
}

Comencemos el anlisis 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 compilacin. En particular #include indica que se debe incluir
informacin 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, librera, etc.) , header de all la extensin .h . Estas librera
contienen lo que se llama en C++ el prototipo de la funcin, que vendra
a ser algo as como su declaracin explcita. Por lo tanto todas las
funciones, salvo main, tienen un prototipo definido en algn 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 compilacin
2. Error ..\MIO\POTENCIA.CPP linea 10: Funcin 'potencia' debe tener un
prototipo.
3. Advertencia.. \MIO\POTENCIA.CPP
'potencia()' sin un prototipo.

10:

Llamada

la

funcin

4. Advertencia.. \MIO\POTENCIA.CPP
'potencia()' sin un prototipo.

10:

Llamada

la

funcin

La linea 3 y 4 se debe a que potencia() fue invocada dos veces.


Por lo tanto declarar el prototipo de la funcin a utilizar es muy
importante e imprescindible, puesto que no compilaremos el programa
adecuadamente. La porcin de cdigo que nos interesa ms es la que va
del numero de linea 14 a lnea 20. Estas lneas contienen una funcin
cuyo prototipo fue declarado explcitamente en la lnea 3. Esta funcin
retorna un valor long double y recibe como parmetros dos valores
enteros. El valor de retorno, y el control a la funcin que llama o el

sistema operativo en el caso de main, es reintegrado a travs de la


sentencia return en las lneas 11 y 18. Return puede tener a
continuacin cualquier expresin de cualquier tipo, si es necesario el
valor se convertir al tipo de retorno.
Argumentos
En C++, todos los argumentos de una funcin se pasan por valor.
Esto significa que la funcin que se invoca recibe los valores de sus
argumentos en variables temporales y no en las originales. Esto es, la
funcin que se invoca no puede alterar directamente una variable de la
funcin que hace la llamada; solo puede modificar su copia privada y
local.
Cuando es necesario, es posible hacer que una funcin modifique una
variable dentro de una rutina invocada. La funcin que llama debe
proporcionar la direccin de la variable que se cambiar (tcnicamente
un apuntador a la variable) y la funcin que se invoca debe declarar que
el parmetro sea un apuntador y tengo acceso a la variable
indirectamente a travs de l.
Veamos algunos ejemplos:
Supongamos que estamos haciendo un ordenamiento de elementos
de un arreglo de enteros. Dicho ordenamiento requiere en algn
momento, el intercambio entre dos elementos de dicho arreglo, y para
realizar tal tarea, recurrimos a una funcin:
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 funcin 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 implcitos a enteros y por lo tanto cumplen con
el requisito de paso de valores por referencia, requisito fundamental
para que una funcin 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 funcin es la
localizacin o la direccin del principio del arreglo -no hay copia de los
elementos del arreglo. Al colocarle subndices a este valor, la funcin
puede tener acceso y alterar cualquier elemento del arreglo por
ejemplo:
A continuacin presentamos un programa que realiza una carga de
datos en dos matrices, y luego llama a una funcin para realizar la suma
de sus elementos y mostrar los resultados en pantalla. De esta manera
ilustramos el pasaje de parmetros tipo arrays a funciones.
/
*************************************************************
***********
CALCULA LA SUMA DE DOS MATRICES DEL MISMO TAMAO
*************************************************************
***********/
#include <iostream.h>
#include <conio.h>
// prototipo de la funcin sumar
void sumar(long double a[][50],long double b[][50],int m,int n);
void main(void) // funcin 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 tamao de las filas no es necesario, pero el compilador necesita


saber cual es el tamao de la segunda dimensin o tamao de las
columnas es por ello que se debe informar al compilador acerca de cuan
grande es la segunda dimensin.
Por otro lado si lo que se pasa como argumento a una funcin es un
elemento determinado del array, este elemento es tratado como una
variable comn por lo tanto deberemos pasar su localizacin en
memoria a travs de un puntero como lo hacemos para las llamadas a
referencia con variables.
Con el siguiente ejemplo, daremos una explicacin 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;
}
/*********mtodo 1***********/
void mostrar(int num[10])
{
int i;
for(i=0;i < 10;i++) cout << num[i];
}
/*********mtodo 2***********/
void mostrar(int num[]) //reemplazamos el prototipo y la funcin
{
int i;
for(i=0;i < 10;i++) cout << num[i];
}
/*********mtodo 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 ms 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
#include
#include
#include

for

<stdio.h>
<iostream.h>
<ctype.h>
<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
{

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 tabulacin
//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.

maysculas.

cout
<<
"Salir
sal=toupper(getche()); //

S
o
toupper(char

N
c)

?:
";
convierte a
}

Para finalizar daremos a continuacin una lista de las libreras


asociadas a turbo C y cuales funciones soportan o definen su prototipo.
Archivos de cabecera de Turbo C++.
Nombre
archivo

delFunciones relacionadas

alloc.h

Asignacin dinmica de memoria.

assert.h

Define assert().

bios.h

Funciones de interfaz con el BIOS.

conio.h

Funciones
consola.

de

entrada/salida

complex.h

Funciones
complejos

de

manipulacin

ctype.h

Funciones relacionadas con caracteres.

dir.h

Funciones relacionadas con directorios.

dos.h

Funciones de interfaz con el DOS.

directa
de

por

nmeros

errno.h

Define varios cdigos de error.

fcntl.h

Define varias constantes utilizadas


sistema de archivos tipo UNIX.

float.h

Define los lmites de reales en coma flotante.

graphics.h

Funciones relacionadas con grficos.

io.h

Funciones de entrada/salida.

iostream.h

Funciones de entrada/salida.

iomanip.h

Funciones de manipulacin de formatos de


salida o entrada.

limits.h

Define varios lmites de enteros.

locale.h

Funciones especficas de pases.

math.h

Funciones matemticas.

mem.h

Funciones de manipulacin de memoria.

process.h

Funciones de control de procesos.

setjmp.h

Requerido por setjmp() y longjmp().

share.h

Funciones de soporte a la comparticin de


archivos.

signal.h

Soporte para signal() y raise().

stdargs.h

Soporte para argumentos de longitud variable.

stddef.h

Define tipos y macros estndar.

stdio.h

Funciones de entrada/salida estndar.

stdlib.h

Funciones variadas.

string.h

Funciones relacionadas con archivos.

sys/stat.h

Constantes relacionadas con archivos.

sys/timeb.h

Soporta la funcin ftime().

por

el

sys/types.h

Define time_t, usado por las funciones de hora.

time.h

Funciones de hora y fecha.

values.h

Varias
constantes
implantacin.

dependientes

de

la

A continuacin describimos algunas de las funciones ms importantes


y sus respectivas libreras 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 funcin muestra un caracter en la pantalla y retorna como un
entero el valor del caracter impreso.
En esta librera estn definidas las funciones de manipulacin de
pantallas de texto. A continuacin el listado de las mas importantes:
void clrscr(void);

Limpia la ventana activa.

void clreol(void);

Limpia desde la posicin del cursor


hasta el final de la lnea de la ventana
activa.

void delline(void);

Borra la linea en donde esta ubicado el


cursor.

void gotoxy(int x, int


y);

Ubica el cursor en las coordenadas


establecidas.

void insline(void);

Inserta una linea a partir de la posicin


actual del cursor.

void textattr(int
atributo);

Define el atributo de texto de la ventana


activa, color de frente y de fondo.

void textcolor(int

Define el color de frente del la ventana

color);

activa.

void
textbackground(int
color);

Define el color de fondo de la ventana


activa.

void highvideo(void);

Muestra el texto en alta intensidad.

void lowvideo(void);

Muestra el texto en baja intensidad.

void normvideo(void);

Muestra
original.

int wherex(void);

Devuelve la coordenada x del cursor.

int wherey(void);

Devuelve la coordenada y del cursor.

void textmode(int
modo);

Establece el modo de video.

el

texto

en

la

intensidad

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 matemticas
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 numricos 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 hiperblico 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 funcin 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 hiperblico de un argumento double y retorna un
valor double.
double sqrt (double x);
Calcula la raz 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 hiperblica 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 precisin de clculo.
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
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define
#define

M_E 2.71828182845904523536
M_LOG2E 1.44269504088896340736
M_LOG10E 0.434294481903251827651
M_LN2 0.693147180559945309417
M_LN10 2.30258509299404568402
M_PI 3.14159265358979323846
M_PI_2 1.57079632679489661923
M_PI_4 0.785398163397448309616
M_1_PI 0.318309886183790671538
M_2_PI 0.636619772367581343076
M_1_SQRTPI 0.564189583547756286948
M_2_SQRTPI 1.12837916709551257390
M_SQRT2 1.41421356237309504880
M_SQRT_2 0.707106781186547524401

Consideraciones
Para mas referencias a las funciones disponibles consultar la ayuda de
Turbo C++.
Para mas bibliografia, consultar cualquier libro de Progamacin C++
de cualquier autor.