Guia C++

LENGUAJE DE PROGRAMACION I
DEV C++
Ing. JAVIER ECHEGARAY ROJO

Ing. WILDER ROMAN MUNIVE
Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive
Pag 1
DEV C++
CAPTULO 1 INTRODUCCIN AL LENGUAJE C++...................................3

1.1 Estructura bsica de un programa..............................................3
CAPITULO 2
VARIABLES .TIPOS DE DATOS EN C++..........................8
2.1 Identificador, definicin.............................................................8
2.2 Identificadores C++.................................................................8
2.3 Tipos de datos fundamentales....................................................9
2.4 Variables...............................................................................10
2.5 Inicializacion de variables........................................................13
2.6 Introduccin a cadenas...........................................................14
2.7 Literales................................................................................15
2.8 Numeros Enteros...................................................................16
2.9 Nmeros de Punto flotante......................................................16
2.10 Caracter y cadena de caracteres.............................................17
2. 11 Literales Booleanos..............................................................19
2.12 Constantes definidas (#define)...............................................19
2.13 Declaracion de constantes (const)................................................................20
2.14 OPERADORES.............................................................................................................20
2.14.1Asignacion (=)................................................................................................21
2.14.2 Operadores Arimeticos ( +, -, *, /, % )..............................................22
2.14.3 Operadores compuestos............................................................................23
2.14.4 Incremento y decremento(++, --)........................................................23
2.14.5 Operadores Relacionales y de Igualdad..............................................24
2.14.6 Operadores logicos ( !, &&, || )..............................................................25
2.14.7 Operador ||.....................................................................................................26
2.14.8 Operador condicional ( ? )........................................................................26
2.14.9 Operador Coma ( , )..................................................................................27
2.14.10 Operador tipo Casting ( Conversin de tipo de datos)..............27
2.15 Jerarquia de operadores...................................................................................28
CAPITULO 3. ENTRADA Y SALIDA BSICA.....................................................................30
3.1 Salida standar(cout)..............................................................................................30
3.2 Salida estandar(cin)..............................................................................................32
CAPITULO IV ESTRUCTURAS DE CONTROL..................................................................34
4.1 Estructura Condicional : if.. else.......................................................................34
4.2 La estructura selectiva : switch........................................................................38
4.3 El lazo while..............................................................................................................42
4.4 El lazo do-while........................................................................................................44
4.5 El lazo For..................................................................................................................46
4.6 La instruccion break.............................................................................................49
4.7 Instruccion continue..............................................................................................49
4.8 La instruccion goto................................................................................................50
Pag 2
DEV C++
CAPTULO 1 INTRODUCCIN AL LENGUAJE C++
1.1 ESTRUCTURA BSICA DE UN PROGRAMA

Programa # 1.
#include <iostream > //declaracin de libreras
using namespace std;
int main() //funcion main
{
cout<<Bienvenido al mundo de C++<<endl; //instrucciones
system(pause ); //pausa
return 0; //valor de retorno de la funcin
} //llaves de cierre de la funcin
Ejecucin del programa
Bienvenido al Mundo de C++
Presione una tecla para continuar . . .
1.2 COMO USAR DEV C++

Una vez instalado el dev-cpp lo primero que debemos hacer para empezar a crear un
programa es crear un archivo fuente (Source File).
Para crear un archivo haremos clic en archivo-> new- > Source file.
Pag 3
DEV C++
A continuacin nos aparecer LA VENTANA DE EDICION DE CODIGO, donde se

deber ingresar las instrucciones o el cdigo del Programa
Una vez de haber concluido con la escritura del cdigo es necesario Compilar y luego
ejecutar.
Para Compilar el programa hacer clic en Execute ->compile (Ctrl. +F9)
En caso de que algo exista

errores en el codigo , nos
aparecera en la parte inferior
una ventana con los errores.
VENTANA DE ERRORES
Cuando esta libre de errores la

en la ventana status deber
Aparecer el Mensaje Done y
estara listo para Ejecutarse.
Para Ejecutar el el
programa hacer clic en Execute
->Run (Ctrl. +F10)
Pag 4
DEV C++
Como resultado obtendremos;
NOTA : Tambien podremos utilizar la barra de herramientas compile y Run para compilar
y ejecutar nuestros programas
Compilar
ejecutar
compilar y ejecutar
Analicemos cada parte de nuestro primer programa.

#include <iostream>
La parte del #include se refiere a la biblioteca de funciones que vamos a utilizar.
Es decir para llamar a una biblioteca en particular debemos hacer lo siguiente:
#include <librera_solicitada>
El estndar de C++ incluye varias bibliotecas de funciones, y dependiendo del
compilador que se est usando, puede aumentar el nmero.
Pag 5
DEV C++

Esta sentencia cambia una configuracin en el compilador para que las funciones
de la librera iostream nos funcionen bien.
int main( ){
Todo programa en C++ comienza con una funcin main(), y slo puede haber
una. En C++ el main() siempre regresa un entero, es por eso se antepone int a
la palabra main. Los parntesis que le siguen contienen lo que se le va a
mandar a la funcin , en este caso puede ser void o no contener nada. La llave
que se abre significa que se iniciar un bloque de instrucciones.
cout<<Bienvenido al mundo de C++<<endl ;
Esta es una instruccin. La instruccin cout est definida dentro de la biblioteca
iostream., que previamente declaramos que bamos a utilizar. Una funcin, en
este caso main() siempre comienza su ejecucin con una instruccin (la que se
encuentra en la parte superior), y contina as hasta que se llegue a la ltima
instruccin (de la parte inferior). Para terminar una instruccin siempre se coloca
;.
Pero adems de instrucciones se pueden invocar funciones definidas por el
usuario (por supuesto diferentes de main) como se ver mas adelante.
system(pause);
Esta instruccin permite una pausa para que se pueda visualizar el resultado.
return 0;
Esta es otra instruccin, en este caso la instruccin return determina que es lo
que se devolver de la funcin main(). Habamos declarado que main devolvera
un entero, as que la instruccin return devuelve 0. Lo cual a su vez significa que
no han ocurrido errores durante su ejecucin.
}
La llave de cierre de la funcin main() indica el termino del bloque de
instrucciones.
En algunos programas de ejemplo, notar el uso de dobles diagonales (//).
Estas
diagonales se usan para escribir comentarios de una lnea dentro del cdigo del
Pag 6
DEV C++
programa. Adems podr encontrar el uso de /* */ estos caracteres encierran

un
comentario de varias lneas y cualquier cosa que se escriba dentro de ella no
influenciar en el desempeo del programa.
Tambin ver que muchas veces utilizaremos una diagonal invertida (\). Este
signo
se utiliza cuando una instruccin ocupar varias lneas y por razones de espacio
en
la hoja es mejor dividirla en partes.
Pag 7
CAPITULO 2
DEV C++
VARIABLES .TIPOS DE DATOS EN C++
2.1 Identificador, definicin

un identificador es un conjunto de caracteres alfanumricos de cualquier longitud
que sirve para identificar las entidades del programa (clases, funciones,
variables, tipos compuestos, Etc.) Los identificadores pueden ser combinaciones
de letras y nmeros. Cada lenguaje tiene sus propias reglas que definen como
pueden estar construidos. En el caso de C++, son las que se indican a
continuacin. Cuando un identificador se asocia a una entidad concreta, entonces
es el "nombre" de dicha entidad, y en adelante la representa en el programa. Por
supuesto puede ocurrir que varios identificadores se refieran a una misma
entidad.
Nota: el concepto de "entidad" es muy amplio; corresponde a: un valor; clase;
elemento de una matriz; variable; funcin; miembro de clase; instancia de clase;
enumerador; plantilla, o espacio de nombres del programa.
2.2 Identificadores C++
Los identificadores C++ pueden contener las letras a a z y A a Z, el guin bajo
"_" ("Underscore") y los dgitos 0 a 9.
Caracteres permitidos:
abcdefghijklmnopqrstuvwxyz
ABCDEFGHIJKLMNOPQRSTUVWXY
Z
_
Dgitos permitidos
Pag 8
DEV C++
0123456789
Solo hay dos restricciones en cuanto a la composicin:
El primer carcter debe ser una letra o el guin bajo. El Estndar establece que
los identificadores comenzando con guin bajo y mayscula no deben ser
utilizados. Este tipo de nombres se reserva para los compiladores y las Libreras
Estndar. Tampoco se permite la utilizacin de nombres que contengan dos
guiones bajos seguidos.
El estndar ANSI establece que como mnimo sern significativos los 31 primeros
caracteres, aunque pueden ser ms, segn la implementacin [1]. Es decir, para
que un compilador se adhiera al estndar ANSI, debe considerar como
significativos, al menos, los 31 primeros caracteres.
Los identificadores distinguen maysculas y minsculas, as que Sum, sum y suM
son distintos para el compilador.
2.3 TIPOS DE DATOS FUNDAMENTALES

Los prototipos de variables utilizados en los programas de ejemplo, hasta el
momento, han sido en su mayora de tipo entero (int), pero es ilgico pensar que
ste sea el nico que se llegue a utilizar. Adems del tipo entero existen otros.
Los tipos de datos atmicos son los tipos de datos ms sencillos a partir de los
cuales se pueden construir otros ms complejos. La siguiente tabla ilustra estos
tipos con sus intervalos de valores posibles y el nmero de bytes que ocupan.
Nombre
Descripcion
tam*
Rango*
signed: -128 to 127
unsigned: 0 to 255
Carcter o pequeos enteros .
1byte
Entero corto
signed: -32768 to
2bytes 32767
unsigned: 0 to 65535
int
Entero
signed: -2147483648
to 2147483647
4bytes
unsigned: 0 to
4294967295
long int
(long)
Entero largo.
char
short int
(short)
4bytes signed: -2147483648

to 2147483647
unsigned: 0 to
4294967295
Pag 9
DEV C++
bool
Valor Booleano. Puede tomar 2

valores: true(1) o false(0).
1byte
float
Numero de punto flotante
4bytes 3.4e +/- 38 (7 digits)
double
Numero de punto flotante doble

precisin
8bytes 1.7e +/- 308 (15 digits)
long double Numero largo de punto flotante

doble precision
8bytes 1.7e +/- 308 (15 digits)
1 o 0
2.4 VARIABLES
Anteriormente vimos la forma general de un programa, un programa
sumamente sencillo. Ahora veamos un programa muy parecido al anterior:
Programa # 2
#include <iostream>
int main( ){
int variable;
variable=5;
cout<<variable;
system(pause);
return 0;
}
10
Notemos en esta ocasin slo la parte: int variable; . A esta seccin se le
denomina declaracin. Se trata de la declaracin de una variable de nombre
variable.
Una variable es una posicin de memoria con nombre que se usa para mantener
un valor que puede ser modificado por el programa3. Las variables son
declaradas, usadas y liberadas. Una declaracin se encuentra ligada a un tipo, a
un nombre y a un valor.
Bsicamente , la declaracin de una variable presenta el siguiente aspecto:
tipo nombre [=valor];
10
Pag
DEV C++
Los corchetes significan que esa parte es opcional. Por ejemplo, la declaracin:
int mi_variable=5;
declara una variable tipo entero de nombre mi_variable y le asigna el valor 5.
C++ es sensible a maysculas y minsculas, as que si el nombre de nuestra
variable empieza con una letra en maysculas, debemos de asegurarnos que
durante el resto del cdigo nos refiramos a ella exactamente como la escribimos.
Los nombres de las variables no pueden usar signos de puntuacin, slo
caracteres A-Z, a-z, _, 0- 9, aunque ningn nombre debe comenzar con un
nmero (0-9). Adems no se deben de repetir nombres de variables en el mismo
contexto.
Adems de las restricciones anteriores, existe otra, y esta tiene que ver con las
palabras reservadas del lenguaje, que no son muchas a comparacin de otros
lenguajes como Basic. Las palabras que se presentan en la siguiente lista, no
pueden ocuparse como nombres de variables, funciones, u otras instrucciones
definidas por el programador.
asm, auto, bool, break, case, catch, char, class, const, const_cast,
continue, default, delete, do, double, dynamic_cast, else, enum,
explicit, export, extern, false, float, for, friend, goto, if,
inline, int, long, mutable, namespace, new, operator, private,
protected, public, register, reinterpret_cast, return, short,
signed, sizeof, static, static_cast, struct, switch, template, this,
throw, true, try, typedef, typeid, typename, union, unsigned, using,
virtual, void, volatile, wchar_t, while
Las variables se pueden declarar en tres sitios bsicos: dentro de las funciones
(ya sea la funcin main u otras creadas por el programador), estas variables son
llamadas locales; en la definicin de parmetros de una funcin, como se ver
ms adelante; y fuera de todas las funciones, variables globales.
Programa # 3
#include <iostream>
int variable_global=10;
int main(){
int variable_local=20;
cout<<"\nprograma que muestra los usos de variables globales y
locales\n"<<endl;
cout<<"la variable global tiene asignado un
<<variable_global<<endl;
cout<<"\nla variable local tiene asignado un "
11
Pag
DEV C++
<<variable_local<<endl;
system(pause);
return 0;
}
Ejecucin del programa:
Programa que muestra los usos de las variables globales y locales
La variable global tiene asignado un 10
La variable local tiene asignado un 20
Una variable global puede ser modificada en cualquier parte del programa,
mientras que una variable local slo puede ser modificada y utilizada dentro de la
funcin en la que se ha declarado. Por supuesto, antes de utilizar una variable y
hacer operaciones con ella, hay que declararla.
Por lo general, siempre se trata de utilizar lo menos posible la declaracin de
variables globales. El siguiente ejemplo muestra que se pueden declarar
variables en cualquier parte del programa, siempre y cuando se declaren antes
de usarlas.
programa # 4
#include <iostream>
int main( ){
int variable1=10;
cout<<"la variable 1 tiene almacenado un: "
<<variable1<<endl;
variable1=50;
int variable2=variable1+30;
cout<<"\nla variable 2 almacena un: "
<<variable2<<endl;
system(pause);
return 0;
}
La variable 1 tiene almacenado un 10
La variable 2 almacena un 80
Presione una tecla para continuar. . .
En un programa puede que necesitemos declarar un dato y asignarle un nombre,

pero que ste no pueda ser modificado. En este caso debemos declarar una
constante.
12
Pag
DEV C++
Por ejemplo, el siguiente programa calcula el rea de un crculo.

Programa # 5
#include <iostream>
int main( ){
const float pi=3.141592;
int radio=5;
float area;
area=pi*radio*radio;
cout<<"el area del circulo es: "<<area<<endl;
system(pause);
return 0;
}
Ejecucion del programa
El area del circulo es : 78.5398
Presione una Tecla para continuar
Declaramos una constante del tipo de datos float , le damos el nombre pi y le
asignamos el valor 3.141592. Este valor jams podr ser modificado en ninguna
parte del programa
2.5 Inicializacion de variables
Cuando declaramos una variable local, su valor es por defecto indeterminado.
Pero usted puede querer que esa variable almacene un valor a la vez que es
declarado . Para hacer esto, usted puede inicializar la variable. Hay dos modos de
hacer esto en C ++:
El primer modo es aadiendo un signo igual seguido del valor al cual la variable
ser inicializada:
tipo identificador
= valor_inicial ;
Por ejemplo, si queremos declarar que una variable int de nombre a y que sea
inicializada con un valor 0 en el momento que es declarado , nosotros podramos
escribir:
int a = 0;
Otro modo de inicializar variables se realiza incluyendo el valor inicial entre

parntesis (()):
tipo identificador (valor_inicial) ;
Por ejemplo :

13
Pag
DEV C++
int a (0);
Ambas formas son validas y equivalentes en C++
Veamos el siguiente ejemplo :
Programa # 6
// inicializacion de variables
#include <iostream>
int main ()
{
int a=5;
// valor inicial = 5
int b(2);
// valor inicial = 2
int resultado;
// valor inicial indeterminado
a = a + 3;
resultado = a - b;
cout << resultado<<endl;
system(pause);
return 0;
}
Ejecucin del programa :
6
2.6 Introduccin a cadenas
Las variables que pueden almacenar los valores no numricos que son ms largos
que un carcter son conocidas como cadenas.
El librera del lenguaje C ++ proporciona el soporte a las cadenas mediante la
clase estandar string . Este no es un tipo fundamental, pero se comporta de un
modo similar como tipos fundamentales haciendo su uso ms sencillo.
Una primera diferencia con los tipos de datos fundamentales es que para
declarar y usar las variables de este tipo tenemos que incluir un archivo de
cabecera adicional en nuestro cdigo original: <string>
programa # 7
// mi primera cadena
#include <iostream>
#include <string>
int main (){
string micadena = "Ao del deber ciudadano";
cout << micadena<<endl;
14
Pag
DEV C++
system(pause);
return 0;
}

Ao del deber ciudadano
Como usted puede ver en el ejemplo anterior, las cadenas
pueden ser
inicializadas con cualquier literal de cadena vlido como las variables de tipo
numricas puede ser inicializado a cualquier literal vlido numrico. Ambos
formatos de inicializacin son vlidos con cadenas:
string micadena = "Ao del deber ciudadano";
string micadena ("Ao del deber ciudadano");
Las cadenas tambin pueden realizar todas las otras operaciones bsicas que
realizan los tipos de datos fundamentales , como ser declarado sin un valor inicial
y asignrsele valores durante la ejecucin:
Programa # 8
// mi primera cadena
#include <iostream>
#include <string>
int main (){
string mensaje;
mensaje = "Esta es la cadena inicial";
cout << mensaje << endl;
mensaje = "Esta es una cadena diferente";
cout << mensaje << endl;
system(pause );
return 0;
}
Ejecucin del Programa :
Esta es la cadena inicial
Esta es una cadena diferente
Presione una tecla para continuar
CONSTANTES
Las constantes son expresiones con un valor que permanece fijo.

15
Pag
DEV C++
2.7 Literales
Los literales son usados para expresar valores particulares dentro del cdigo
original de un programa. Ya hemos usado estos antes para dar valores concretos
a variables o expresar mensajes que quisimos que nuestros programas
imprimieran, por ejemplo, cuando escribimos
a = 10;
El 10 en este pedazo de cdigo es un literal constante.
El literales constantes puede ser dividido en Nmeros enteros, Nmeros de
Punto flotante, Carcteres, Cadenas y Valores Booleanos.
2.8 Numeros Enteros
1652
507
-274
Los nmeros anteriores son constantes
numricos
que identifica valores
decimales enteros . Ntese que para expresar una
constante numrica no
tenemos que escribir comillas dobles ("), ni ningn carcter especial. No hay
duda que es un constante: siempre que nosotros escribamos 1776 en un
programa, nos referiremos al valor 1776.
Adems de nmeros decimales (aquellos que usamos cada da) C ++ permite el
empleo como literales constantes de nmeros octales (base 8) y nmeros
hexadecimales (base 16). Si queremos expresar un nmero octal tenemos que
precederlo con 0 (el carcter cero). Y para expresar un nmero hexadecimal
tenemos que precederlo con los carcteres 0x . Por ejemplo, los literales
constantes siguiente son equivalentes
75
0113
0x4b
// decimal
// octal
// hexadecimal
Todos estos representan el mismo nmero: 75 (setenta y cinco) expresado como

un numero en base 10 , nmero octal y nmero hexadecimal, respectivamente.
Los literales constantes, como variables, son considerados que tienen un tipo
de dato especifico . Por defecto, los literales enteros son de tipo int. Sin
embargo, podemos forzarlos a ser unsigned (sin signo) aadindole el carcter
u, o enteros mas largos aadiendo la l:
75
75u
75l
75ul
//
//
//
//
int
unsigned int
long
unsigned long

16
Pag
DEV C++
En ambos casos, el sufijo puede ser especificado usando letras maysculas o

minsculas.
2.9 Nmeros de Punto flotante

Ellos expresan nmeros con decimales y/o exponentes. Pueden incluir un punto
decimal, un carcter e (que expresa el exponente al que esta elevada la base
10)
3.14159
6.02e23
1.6e-19
3.0
//
//
//
//
3.14159
6.02 x 1023
1.6 x 10-19
3.0
Estos son cuatro nmeros vlidos con decimales expresados en C ++. El primer
nmero es la PI, el segundo es el nmero de Avogadro, el tercero es la carga
elctrica de un electrn (un numero sumamente pequeo ) - todos ellos
aproximados - y el ltimo es el nmero tres expresado como literal numrico de
punto flotante .
El tipo de por defecto para literales de punto flotante es double. Si usted
explcitamente quiere expresar explcitamente literal numrico float o long
double , podr usar los sufijos de f l respectivamente:
3.14159L
6.02e23f
// long double
// float
Cualquiera de las letras pueden ser de una constante numrica de punto

flotante punto flotante ( e, f, l) puede ser escrita usando letras maysculas o
minsculas .
2.10 Caracter y cadena de caracteres
Tambin existen constantes no numricas , como:

'z'
'p'
"UNICA"
"como estas?"
Las dos primeras expresiones representan el carcteres solo constantes, y los dos
siguientes representan literales de cadenas compuestas por varios caracteres .
Note que para representar un carcter solo lo incluimos entre comillas simples (')
y las cadenas entre comillas dobles (").

17
Pag
DEV C++
Escribiendo tanto el carcter simples como las cadenas de caracteres , es

necesario ponerlos entre comillas para diferenciarlos de los identificadores de
variables
o palabras reservadas . observe
la diferencia entre estas dos
expresiones:
x
'x'
x solo se refiere a una variable cuyo identificador es x, mientras que 'x' (incluido
dentro de comillas simples) mandara al carcter 'x' constante.
El carcter y la cadena de caracteres tienen ciertas particularidades, como las
secuencias de escape. Estos son los carcteres especiales que son difciles o
imposibles expresar de otra manera en el cdigo original de un programa, como
cambio de linea (\n) o la tabulacion (\t). Todos ellos son precedidos por un
backslash (\). Aqu usted tiene una lista de algunos de tales secuencias de
escape:
\n Linea nueva
\r Retorno de carro
\t tab
\v Tab vertical
\b backspace
\f form feed (page feed)
\a Alarma sonora
\' Comilla simple(')
\" Comilla doble (")
\? Signo interrogacion (?)
\\ backslash (\)
Por ejemplo:
'\n'
'\t'
"izquierda \t derecha"
"uno\ndos\ntres"
Adicionalmente, usted puede expresar cualquier carcter por su cdigo numerico
ASCII escribiendo un carcter backslash (\) seguido del cdigo de ASCII
expresado como un numero octal (base 8) o hexadecimal (base 16) . En el
primer caso (octal) los dgitos inmediatamente deben seguir el backslash (por
ejemplo \23 o \40), en el segundo caso (hexadecimal), un carcter x debe ser
escrito antes de los dgitos ellos mismos (por ejemplo \x20 o \x4A).
18
Pag
DEV C++
Las cadenas de caracteres

pueden extenderse por mas de una linea de
colocando un signo de backslash (\) al final de cada lnea a continuar.
"cadena expresada
dos lineas"
en \
Usted tambin puede concatenar varias cadenas separandolas por una o varios
espacios en blanco, tabuladores o newline .
"esto forma " "una simple " "cadena " "de caracteres"
Finalmente , si deseamos escribir amplias cadenas de caracteres podemos
prcederla con el prefijo L :
L"Esta es una amplia cadena de caracteres"
2. 11 Literales Booleanos
Hay slo dos valores vlidos Booleanos: verdadero y falso. Estos pueden ser
expresados en C ++ como los valores de tipo bool por usando los literales
Booleanos verdaderos y falsos.
2.12 Constantes definidas (#define)

Usted puede definir sus propios nombres para constantes que usa muy a menudo
sin necesidad recurrir a variables que consumen
demasiada memoria ,
simplemente por usando la directiva de preprocesador #define. Su formato es:
#define identificador valor
Por ejemplo:
#define PI 3.14159265
#define NUEVALINEA '\n'
Esto define dos nuevos constantes: PI Y NUEVALINEA. Una vez que ellos son
definidos, usted puede usarlos en el resto del cdigo como cualquier otra
constante regular, por ejemplo:
Programa # 9
// constantes definidas : calcula rea del circulo

#include <iostream>
19
Pag
DEV C++
#define PI 3.14159
#define NUEVALINEA '\n';
int main (){
double r=5.0;
double circle;
//radio
circle = 2 * PI * r;
cout << circle;
cout << NUEVALINEA;
system(pause);
return 0;
Ejecucion del programa :

31.4159
De hecho la nica cosa que el preprocesador del compilador
hace cuando
encuentra directivas #define es de
sustituir cualquier presencia de su
identificador (en el ejemplo anterior, estos eran la PI Y NUEVALINEA) por el
cdigo al cual ellos han sido definidos (3.14159265 y '\n ' respectivamente).
La directiva #define no es una instruccin C ++ , sino una directiva para el
preprocesador; por lo tanto se asume la lnea entera como la directiva y no se
requiere un punto y coma (;) a su final.
2.13 Declaracion de constantes (const)
With the const prefix you can declare constants with a specific type in the same
way as you would do with a variable:
Con el prefijo const se puede declarar las constantes con un tipo de dato
especifico de la misma forma que para declarar las variables:
const int Ancho = 100;
const char tabulador = '\t';
const zipcode = 12440;
En caso de que no sea especificado ningun tipo de dato , compilador asume que
es de tipo int.
2.14 OPERADORES
Ahora que sabemos de
la existencia de variables y constantes, podemos
comenzar a operar con ellos. Para tal objetivo, C ++ integra a los operadores. A
diferencia de otras lenguajes cuyos operadores son principalmente las palabras
20
Pag
DEV C++
clave, los operadores en C ++ mayormente son hechas de los signos que no

son la parte del alfabeto, pero estn disponibles en todos los teclados. Esto hace
del C ++ un lenguaje con cdigos mas cortos e internacional , ya que esto
significa menos palabras en Ingles , pero requieren un poco de esfuerzo inicial
para su aprendizaje.
2.14.1Asignacion (=)
El operador de Asignacin asigna un valor a la variable.
a = 5;
Esta declaracin asigna el nmero entero 5 a la variable a. la parte en el lado
izquierdo del operador de asignacin (=)es conocida como el lvalue (el valor
izquierdo) y el derecho como el rvalue (el valor derecho). El lvalue tiene que ser
una variable mientras que el rvalue puede ser un constante, una variable, el
resultado de una operacin o cualquier combinacin de estos.
La regla ms importante cuando la asignacin es la regla derecha-a-izquierdo: La
operacin de asignacin siempre ocurre del derecho a izquierdo, y nunca en el
otro sentido:
a = b;
Esta declaracin asigna a la variable a (el lvalue) el valor contenido en la variable
b (el rvalue). El valor que fue almacenado hasta este momento en a , no es
considerado en absoluto en esta operacin, y de hecho que el valor es perdido.
Considere tambin que slo asignamos el valor de b a a en el momento de la
operacin de asignacin. Por lo tanto un cambio posterior de b no afectar el
nuevo valor de a.
Veamos el siguiente programa
Programa # 10
// operador de asignacin
#include <iostream>
int main ()
{
int a, b;
// a:?, b:?
a = 10;
// a:10, b:?
b = 4;
// a:10, b:4
a = b;
// a:4, b:4
b = 7;
// a:4, b:7
cout << "a:";
cout << a;
cout << " b:";
21
Pag
DEV C++
cout << b<<endl;

system(pause);
return 0;
}
a:4 b:7
Presione cualquier tecla para continuar . . .

Este cdigo nos dar como el resultado que el valor contenido en a es 4 y el
contenido en la b es 7. observe como a no fue afectado por la modificacin final
de b, aun cuando nosotros declarramos a = b anteriormente. Una caracterstica
que C ++ tiene sobre otros lenguajes de programacin es que la operacin de
asignacin puede ser usada como el rvalue (o la parte de un rvalue) para otra
operacin de asignacin. Por ejemplo:
a = 2 + (b = 5);
Es equivalente a:
b = 5;
a = 2 + b;
Esto quiere decir: primero asigne 5 a la variable b y luego asigne a la variable a
el valor 2 ms el resultado de la asignacin anterior de b (es decir 5), quedando
con un valor final de 7. La expresin siguiente es tambin vlida en C ++:
a = b = c = 5;
Asigna el valor de 5 a las tres variables : a, b y c.
2.14.2 Operadores Arimeticos ( +, -, *, /, % )
Las cinco operaciones aritmticas soportadas por el lenguaje C ++ son:
+ adicin
-
sustraccin
multiplicacin
divisin
% Modulo o resto

22
Pag
DEV C++
Las operaciones de adicin, substraccin, multiplicacin y divisin literalmente

estn en correspondencia con sus operadores respectivos matemticos. El nico
que quizs no haya usado puede ser el mdulo; cuyo operador es el signo de
porcentaje (el %). El mdulo es la operacin que da el resto de una divisin de
dos valores. Por ejemplo, si escribimos:
a = 11 % 3;
la variable a contiene el valor 2, donde 2 es el resto de dividirse 11 entre 3.
2.14.3 Operadores compuestos
Cuando queremos modificar el valor de una variable al efectuar una operacin
sobre el valor actualmente almacenado en aquella variable podemos usar los
operadores de asignacin compuestos:
expresin
es equivalente a
valor += incremento;
valor = valor + incremento;
a -= 5;
a = a - 5;
a /= b;
a = a / b;
precio *= unidad + 1; precio = precio * (unidad + 1);

Y lo mismo para todos los otros operadores. Por ejemplo:
Programa # 11
// Operadores de asignacion compuestos

#include <iostream>
int main (){
int a, b=3;
a = b;
a+=2;
// equivalent to a=a+2
cout << a<<endl;
system(pause);
return 0;
}
5
presione una tecla para continuar . . .
2.14.4 Incremento y decremento(++, --)

23
Pag
DEV C++
Simplificando an ms algunas expresiones, el operador de Incremento (++) y el

operador de decremento (-) aumentan o reducen en una unidad el valor
almacenado en una variable. Ellos son equivalentes a + =1 y a - =1,
respectivamente. As
c++;
c+=1;
c=c+1;
Todos son equivalentes en su funcionalidad : Los tres aumentan en una unidad
el valor de c.
. Una caracterstica de este operador es que puede ser usado tanto como un
prefijo como como un sufijo. Esto quiere decir que puede ser escrito antes del
identificador variable (++ a) o despus (a ++). Aunque una simple expresin
como a++ o ++ a tengan exactamente el mismo significado, en otras
expresiones en las cuales el resultado del aumento o la operacin de disminucin
es evaluado como un valor en una expresin externa ellos pueden tener una
diferencia importante en su significado: En el caso que el operador de incremento
como un prefijo (++ a) el valor es aumentado antes de que el resultado de la
expresin sea evaluado y por lo tanto el valor aumentado es considerado en la
expresin externa; en caso de que sea usado como un sufijo (un ++) el valor
almacenado en a es aumentado despus de la evaluacin y por lo tanto el valor
almacenado antes de que la operacin de incremento sea evaluada en la
expresin externa. Note la diferencia:
Ejemplo 1
Ejemplo 2
B=3;
B=3;
A=++B;
A=B++;
// A contiene 4, B contiene 4 // A contiene
3, B contiene
En el Ejemplo 1, la B es incrementada antes de que su valor sea copiado a A.

Mientras en el Ejemplo 2, el valor de B es copiado a A y luego la B es aumentada.
2.14.5 Operadores Relacionales y de Igualdad
Para evaluar una comparacin entre dos expresiones podemos usar los
operadores relacionales y de igualdad . El resultado de una operacin relacional
es un valor Booleano que slo puede ser verdadero o falso. Podemos comparar
dos expresiones, por ejemplo, saber si ellos son iguales o si uno es mayor que el
otro es. Aqu est una lista de los operadores relacionales y de igualdad que
pueden ser usados en C ++:
== Igual a
!=
No igual a
>
Mayor que
<
Menor que

24
Pag
DEV C++
>= Mayor o igual a

<= Menor o gual que
Aqui , algunos ejemplos:
(13 == 3)
(5 > 4)
(3 != 2)
(6 >= 6)
(5 < 5)
// evaluado falso(0).
// evaluado verdadero(1).
// evaluado a falso(0).
Desde luego, en vez de usar solo constantes slo numricas, podemos usar
cualquier expresin vlida, incluyendo variables. Suponga a=2, b=3 y c=6,
(a == 5)
(a*b >= c)
(b+4 > a*c)
((b=2) == a)
// evalua falso debido a que a no es igual a 5.

// verdadero debido a que (2*3 >= 6) es verdadero
// falso debido a que (3+4 > 2*6) es falso.
// verdadero.
Mucho cuidado . El operador = (un signo igual) no es el mismo como el operador

== (dos signos iguales), el primer es un operador de asignacin (asigna el valor
en su derecho a la variable en su izquierdo) y el otro un (==) es el operador de
igualdad que se compara si ambas expresiones en los dos lados de ello son
iguales el uno al otro. As, en la ltima expresin ((b=2) == a), primero
asignamos el valor 2 a la b y luego lo comparamos a a, esto tambin almacena el
valor 2, entonces el resultado de la operacin es verdadero
2.14.6 Operadores logicos ( !, &&, || )
El Operador (!) es el operador C ++ para realizar la operacin Booleana (NOT),
tiene slo un operando, localizado a su derecha , y la nica cosa que hace es
invertir el valor de ello, produciendo falso si su operando es verdadero y
verdadero si su operando es falso. Bsicamente, esto devuelve el valor Booleano
opuesto de su operando . Por ejemplo:
!(5 == 5)
!(6 <= 4)
!true
!false
// da falso(0).
// da verdadero(1)
// da falso(0)
//da verdadero(1).
The logical operators && and || are used when evaluating two expressions to
obtain a single relational result. The operator && corresponds with Boolean logical
operation AND. This operation results true if both its two operands are true, and
false otherwise. The following panel shows the result of operator && evaluating
the expression a && b:

25
Pag
DEV C++
Los operadores lgicos && y || son usados para evaluar dos expresiones para
obtener resultado relacional simple. El operador && corresponde con la
operacin Booleana lgica AND (Y). Esta operacin resulta verdadera si sus dos
operandos son verdaderos o ambos son falsos. La siguiente tabla muestra los
resultados del operador && evaluando la expresin a && b.
a
a && b
El operador || corresponde con la operacin Booleana lgica OR . Esta operacin

resulta verdadero si cualquiera de uno de sus dos operandos es verdadero, y
rsulta falso slo cuando ambos operandos son falsos . Aqu estn los resultados
posibles de a ||b:
Nota : El smbolo | se obtiene mediante la combinacin ALT +124
2.14.7 OPERADOR ||
a
a || b
Por ejemplo:
( (5 == 5) && (3 > 6) ) // da falso( V && F ).
( (5 == 5) || (3 > 6) ) // da verdadero ( V || F ).
2.14.8 OPERADOR CONDICIONAL ( ? )
El operador condicional evala una expresin que devuelve un valor si aquella
expresin es verdadera y otro si la expresin es evaluada como falso. Su formato
es:
condicion ? result1 : result2
Si la condicin es verdadera la expresin devolver el resultado1 , de lo
contrario retornara el resultado2

26
Pag
7==5 ? 4 : 3
7==5+2 ? 4 : 3
5>3 ? a : b
DEV C++
// devuelve 3
// devuelve 4
// devuelve el valor de a.
// conditional operator
#include <iostream>
int main ()
{
int a,b,c;
a=2;
b=7;
c = (a>b) ? a : b;
cout << c;
return 0;

7
presione una tecla para continuar
2.14.9 Operador Coma ( , )

El operador de coma,() se usa para separar dos o ms expresiones que son
incluidas donde slo una expresin es esperada. Cuando el conjunto de
expresiones tiene que ser evaluado para un valor, slo la expresin de derecha es
// programa # 12
//operador condicional
#include <iostream>
int main (){
int a,b,c;
a=2;
b=7;
c = (a>b) ? a : b;
cout << c<<endl;
system(pause);
return 0;
}
considerada.
Por ejemplo , el siguiente cdigo:
27
Pag
DEV C++
a = (b=3, b+2);
Primero asignara el valor 3 a la b, y luego asignara b+2 a la variable a. Tan, al
final, la variable a contendra el valor 5 mientras la variable b contendra el valor
3.
2.14.10 Operador tipo Casting ( Conversin de tipo de datos)
El tipo operador Casting le permite convertir un dato de un tipo dado al otro.
Hay varios modos de hacer esto en C ++. El ms simple, que ha sido heredado
del lenguaje C, debe preceder la expresin para ser convertida por el nuevo tipo
incluido entre parntesis (()):
int i;
float f = 3.14;
i = (int) f;
El cdigo anterior convierte el nmero 3.14 de punto flotante a un valor de
nmero entero (3), el resto se pierde. Aqu, el operador typecasting era (int).
Otro modo de hacer la misma cosa en C ++ es usando la notacin funcional:
precediendo la expresin a ser convertida por el tipo encerrando la expresin
entre parntesis:
i = int ( f );
Ambas formas de conversin de tipos son validos en C++.
2.15 Jerarquia de operadores
Cuando se escriben expresiones complejas con varios operandos, podemos tener
algunas dudas sobre el cual operando es evaluado primero y cual despus . Por
ejemplo, en esta expresin:
a = 5 + 7 % 2
Podremos dudar sobre su interpretacin :
a = 5 + (7 % 2)
a = (5 + 7) % 2
// resulta 6, o
// resulta 0
La respuesta correcta es la primera de las dos expresiones, con un resultado de

6. Hay una orden establecida con la prioridad o jerarquia de cada operador, y no
slo los aritmticos sino para todos los operadores que pueden aparecer en C +
+. Del mayor prioridad a la ms baja, la prioridad es como sigue:
Nive
1
Operador
::

28
Descripcion
ambito
agrupacion
Izq. A der.
Pag
DEV C++
() [] . -> ++ -- dynamic_cast
static_cast reinterpret_cast
const_cast typeid
postfix
++ -- ~ ! sizeof new delete
unario (prefix)
* &
indireccion y
reference
(punteros)
+ -
Operador de signo
unario
(type)
type casting
Der. A izq
.* ->*
Puntero -amiembro
Izq. A der
* / %
multiplicativo
Izq. A der
+ -
aditivo
Izq. A der
<< >>
shift
Izq. A der
< > <= >=
relacional
Izq. A der
10
== !=
equality
Izq. A der
11
&
bitwise AND
Izq. A der
12
bitwise XOR
Izq. A der
13
bitwise OR
Izq. A der
14
&&
logical AND
Izq. A der
15
||
logical OR
Izq. A der
16
?:
condicional
Der. A izq
17
= *= /= %= += -= >>= <<= &= ^= !=
asignacion
Der. A izq
18
coma
Der. A izq
Izq. A der.
Der. A izq
La agrupacin define el orden de preferencia en la cual los operadores son

evaluados en el caso que hay varios operadores del mismo nivel en una
expresin. Todos estos niveles de preferencia para operadores pueden ser
manipulados o hacerse ms simples y sin ambigedades usando signos de
parntesis (), como en este ejemplo:
a = 5 + 7 % 2;
Podra se escrita como:

a = 5 + (7 % 2);
29
Pag
DEV C++
o
a = (5 + 7) % 2;
Dependiendo de la operacin que buscamos
Si se quiere escribir expresiones complicadas y usted no est completamente
seguro de los niveles de preferencia, siempre incluya parntesis. Esto tambin
har un cdigo ms fcil para leer.
CAPITULO 3. ENTRADA Y SALIDA BSICA
Usando la librera estandar de entrada y salida , seremos capaces de interactuar

con el usuario , ya sea por imprimiendo mensajes sobre la pantalla y
permitiendo la entrada del usuario mediante el teclado.
La biblioteca estndar C ++ incluye el archivo de cabecera iostream, donde los
objetos de flujos de entrada y salidas son declaradas.
3.1 Salida standar(cout)
Por defecto, la salida estndar de un programa es la pantalla, y el objeto de flujo
C ++ definido para tener acceso a ello es cout.
cout es usado conjuntamente con el operador de insercin, que es escrito como
<<(dos signos menor).
cout << "sentencia de salida "; // imprime sentencia de salida
cout << 120;
// imprime 120 en pantalla
cout << x;
// imprime el contenido de x
El operador << inserta los datos que lo siguen en el flujo que lo precede. En los
ejemplos anteriores insert la cadena de caracteres sentencia de salida , la
constante numrica 120 y la variable x en el flujo de salida estandar cout.. Note
que la sentencia en la primera instruccin esta incluida entre dobles comillas
(") porque es
una cadena de caracteres. Por ejemplo, estas dos sentencias
tienen resultados muy diferentes:
cout << "Hola";
cout << Hola;
// imprime Hola
// imprime el contenido de la variable hola

30
Pag
DEV C++
El operador de insercin (<<) puede ser usado mas de una vez en una sentencia
simple:
cout << "Hola " << "yo soy " << "una sentencia C++";
Esta ltima declaracin imprimira el mensaje Hola!, soy una sentencia C ++ en
la pantalla. La utilidad de repetir al operador de insercin (<<) es demostrada
cuando queremos imprimir una combinacin de variables y constantes o ms de
una variable
cout << "Hola, tengo

zipcode;
" << age << " aos
and mi codigo es " <<
Si asumimos que la variable de edad contiene el valor 24 y la variable zipcode

contiene 90064 la salida de la declaracin anterior sera:
Hola ,tengo 24 aos y mi codigo es
90064
Es importante notar que cout no aade un salto de lnea despus de su salida a

no ser que nosotros explcitamente lo indiquemos, por lo tanto, las declaraciones
siguientes:
cout << "Esta es una sentencia .";
cout << "Esta es otra sentencia";
mostrar sobre la pantalla uno despus del otro sin ningn salto de lnea entre
ellos:
Esta es una sentencia .Esta es otra Sentencia.
Aun cuando nosotros los hubiramos escrito en dos inserciones diferentes en
cout. Para realizar un salto de lnea sobre la salida explcitamente debemos
insertar un carcter de lnea nueva en cout. En C ++ un carcter de lnea nueva
puede ser especificado como \n (backslash, n):
cout << "Primera sentencia.\n ";
cout << "Segunda sentencia.\nTercera
sentencia.";
Esto produce la siguiente salida :
Primera sentencia.
Segunda sentencia
Tercera sentencia
31
Pag
DEV C++
Adicionalmente , para aadir una nueva lnea podr utilizarse el manipulador

endl. Por ejemplo:
cout << "Primera Sentencia." << endl;
cout << "Segunda sentencia." << endl;
imprimira:
Primera sentencia.
Segunda sentencia.
El manipulador endl produce una nueva lnea , exactamente como la insercin de

'\n ' .
3.2 Entrada estandar(cin).

El dispositivo de entrada estndar es por lo general el teclado. El manejo de la
entrada estndar en C ++ es hecho aplicando al operador de extraccin (>>)
sobre el flujo cin. El operador debe ser seguido de la variable que almacenar los
datos que van a ser extrados del flujo. Por ejemplo:
int edad;
cin >> edad;
La primera declaracin declara una variable de tipo int llamada edad , y el
segundo espera una entrada de cin (desde el teclado) para almacenarlo en esta
variable entera. cin slo puede procesar la entrada del teclado una vez que la
tecla RETURN haya sido presionada. Por lo tanto, incluso si usted solicita un solo
carcter , la extraccin de cin no tratar la entrada hasta que el usuario presione
la tecla RETURN despus que el carcter haya sido ingresado.. Usted siempre
debe considerar el tipo de la variable que se esta usando como un contenedor de
las extracciones cin. Si usted solicita un nmero entero deber recibir un
nmero entero, si usted solicita un carcter , deber recibir un carcter y si
usted solicita una cadena de caracteres usted deber ingresar una cadena de
caracteres.
Programa # 13
//ejemplo entrada y salida
i/o
#include <iostream>
int main ()
{
int i;
32
Pag
DEV C++
cout << "ingrese un valor entero: ";

cin >> i;
cout << "El valor ingresado es " << i;
cout << " y su duplo es " << i*2 << ".\n";
system(pause);
return 0;
}
Ejecucin del programa :
Ingrese un valor entero : 204
El valor ingresado es 204 y su duplo es 408
El usuario de un programa puede ser uno de los factores que generan errores
an en los programas ms simples que usan cin (como el que que acabamos de
ver). Desde si usted solicita un valor de nmero entero y el usuario introducen un
nombre o cadena de caracteres el resultado puede causar su programa una
operacin fallida ya que no es lo que nosotros esperbamos del usuario.
Tambien se podra usar cin cuando se requieran ingresar mas de un dato.
cin >> a >> b;
Es equivalente a:
cin >> a;
cin >> b;
En ambos casos el usuario debe dar dos datos, una para la variable a y el otro
para la variable b que puede ser separada por cualquier separador vlido : un
espacio, un tab o una nueva lnea.
EJERCICIOS PROPUESTOS.
1.- Convertir la edad en aos de una persona a meses.
2.- Convertir soles a dlares.
3.- Evaluar la funcin
para cualquier valor de x.
4.-Calcular el inters que gana un capital de x soles a una tasa de inters del
15% anual en un periodo de n aos.
5.-Dado un numero(N) cualesquiera obtener su raiz y potencia cuadrada .
6.-Convertir C a F.

33
Pag
DEV C++
CAPITULO IV ESTRUCTURAS DE CONTROL

Un programa por lo general no es limitado con una secuencia lineal de
instrucciones. Durante su proceso un programa puede bifurcarse, repetir el
cdigo o tomar decisiones. Para tal objetivo, C ++ proporciona las estructuras de
control que sirven para especificar que es lo que tiene que hacer el programa ,
cuando y bajo cuales circunstancias
Con la introduccin a las estructuras de control vamos tener que tener un nuevo
concepto : la declaracin compuesta o bloque de instrucciones. Un bloque es un
grupo de instrucciones que son separadas por puntos y coma (;) , pero
agrupado juntos en un bloque incluido entre llaves : {}:
{ instruccin1; instruccin2; instruccin3; }
La mayora de las estructuras de control que nosotros veremos en esta seccin
requieren una declaracin genrica como la parte de su sintaxis. Una declaracin
puede ser cualquiera una declaracin simple (una instruccin simple que se
termina con un punto y coma) o una declaracin compuesta (varias instrucciones
agrupadas en un bloque), como el que solamente(justo) descrito. En el caso que
queremos que la declaracin sea una declaracin simple, no tenemos que
incluirlo en abrazaderas ({}). Pero en el caso que queremos que la declaracin
sea una declaracin compuesta debe ser incluido entre llaves ({}), formando un
bloque.
4.1 Estructura Condicional : if.. else

La palabra clave if es usada para ejecutar una declaracin o bloque , slo si una
condicin es verdadera.
(Estructura condicional simple)
Pseudocdigo:
Diagrama de flujo:

34
Pag
DEV C++
Su Sintaxis es:
if (condicin) instruccin
Donde la condicin es la expresin que est siendo evaluada. Si esta condicin es
verdadera, la declaracin es ejecutada. Si es falso, la declaracin no es
ejecutada y el programa sigue directamente despus de esta estructura
condicional.
Por ejemplo, la seccin de cdigo siguiente imprime x es 100 slo si el valor
almacenado en la variable x es igual a 100:
if (x == 100)
cout << "x es 100";
Si queremos que ms de una declaracin sea ejecutada en caso de que la

condicin sea verdadera , podemos especificar un bloque usando llaves {}:
if (x == 100)
{
cout << "x is ";
cout << x;
}
Adems podemos especificar lo que queremos realizar si la condicin no es

verdadera usando la palabra clave else. Su forma usada conjuntamente con if
es:
(estructura Condicional doble)
Pseudocdigo:
Diagrama de flujo:

35
Pag
DEV C++
Sintaxis:
if (condicion) instruccion1 else instruccion2
Por ejemplo:
if (x == 100)
cout << "x es 100";
else
cout << "x no es 100";
Imprime en pantalla x es 100 si x tiene un valor de 100, pero si no es as se

imprime x no es 100.
Las estructuras de comparacin mltiples, son tomas de decisin especializadas que
permiten comparar una variable contra distintos posibles resultados, ejecutando para
cada caso una serie de instrucciones especificas. La forma comn es la siguiente
(estructura condicional Multiple)
Pseudocdigo:
Diagrama de flujo:
Si if + else puede ser concatenado con la intencin de verificar un rango de

valores
El ejemplo siguiente muestra que si el valor actualmente almacenado en x es
positivo, negativo o ninguno de ellos (p. ej. el cero):
if (x > 0)
cout << "x
else if (x <
cout << "x
else
cout << "x
es positivo";
0)
es negativo";
es 0";

36
Pag
DEV C++
Recuerde que en caso de que queremos que ms que una declaracin sola sea
ejecutada, debemos agruparlos en un bloque por incluyndolos entre llaves.
Programas Propuestos
1.- Capturar un nmero cualesquiera e informar si es o no es mayor de 100
2.- Capturar un numero entero cualesquiera e informar si es o no es mltiplo de
4 ( recordar el operador mod(%), analizado en el tema de operadores
aritmticos).
1 - Se ingresan tres notas de un alumno, si el promedio es mayor o igual a once
mostrar el mensaje 'Promocionado'. Tener en cuenta que para obtener
el promedio debemos operar suma=nota1+nota2+nota3; y luego
hacer promedio=suma/3;
3.-Una compaa de alquiler de automviles sin conductor, desea un
programa para emitir las facturas de sus clientes, teniendo presente
los siguientes puntos:
Cantidad fija de $500 si no rebasan los 300 Kms.
Distancia recorrida mayor de 300 Kms.:
Si Dist > 300 Kms. y <= 1000 Kms. se pagar $500 + $30 por Km extra.
Si Dist > 1000 Kms. se pagar $500 $30 por Km extra hasta los primeros
1000 Kms. y $20 por Km.
extra a partir del Km. 1000.
1 - Realizar un programa que lea por teclado dos nmeros, si el primero es mayor al segundo
informar su suma y diferencia, en caso contrario informar el producto y la divisin del
primero respecto al segundo.
2 - Se ingresa por teclado un valor entero, mostrar una leyenda que indique si el nmero es positivo,
cero o negativo.
3 - De un postulante a un empleo, que realiz un test de capacitacin, se obtuvo la siguiente

informacin: nombre del postulante, cantidad total de preguntas que se le realizaron y
cantidad de preguntas que contest correctamente. Se pide confeccionar un programa que lea
los datos del postulante e informe el nivel del mismo segn el porcentaje de respuestas
correctas que ha obtenido, y sabiendo que:
Nivel superior: Porcentaje>=90%.
Nivel medio: Porcentaje>=75% y <90%.
Nivel regular: Porcentaje>=50% y <75%.
Fuera de nivel: Porcentaje<50%.)
4 - De un operario se conoce su sueldo y los aos de antigedad. Se pide confeccionar un
programa que lea los datos de entrada e informe
a) Si el sueldo es inferior a 500 y su antigedad es igual o superior a 10 aos, otorgarle un
aumento del 20 %, mostrar el sueldo a pagar.
b) Si el sueldo es inferior a 500 pero su antigedad es menor a 10 aos, otorgarle un aumento
37
Pag
DEV C++
de 5 %.
c) Si el sueldo es mayor o igual a 500 mostrar el sueldo en la pgina sin cambios
4.2 La estructura selectiva : switch.

Las estructuras Swicht es una estructura de comparacin mltiple, es una toma de
decisin especializada que permiten evaluar una variable con distintos posibles
resultados, ejecutando para cada caso una serie de instrucciones especificas. La forma es
la siguiente:
Pseudocdigo:
Diagrama de flujo:
La sintaxis de la declaracin de swicht es un poco peculiar. Su objetivo es de

comprobar varios valores posibles constantes para una expresin. Algo similar a
que hicimos anteriormente con el anidamiento de varias instrucciones if ..else .
Su Sintaxis es la siguiente:
switch (expresion)
{
case constante1:
grupo de instrucciones 1;
break;
case constante2:
group of statements 2;
38
Pag
DEV C++
break;
.
.
.
default:
grupo default de instrucciones
}
.
Esto trabaja de manera siguiente: switch evala la expresin y comprueba si esto

es equivalente a constante1, si es asi , se ejecuta el grupo de declaraciones 1
hasta que encuentre la instruccin Break. Cuando encuentra la instruccin
BREAK el programa salta al final de la estructura selectiva Switch.
Si la expresin no fuera igual a constante1 , debera evaluarse la constante2 y si
es verdadera ejecutara el grupo de instrucciones 2 hasta que encuentre la
instruccin break y luego brincar al final del interruptor la estructura selectiva
swicht.
Finalmente, si el valor de expresin no coincide con ninguna de las constantes el
programa ejecutar las declaraciones incluidas despus de default .
Ambos de los fragmentos de codigo siguientes, tienen el mismo comportamiento
Ejemplo switch
Equivalente if-else
switch (x) {
if (x == 1) {
case 1:
cout << "x es 1";
cout << "x es 1";
}
break;
else if (x == 2) {
case 2:
cout << "x es 2";
cout << "x es 2";
}
break;
else {
default:
cout << " valor de x desconocido ";
cout << "valor de x desconocido";
}
}
La instruccin switch es un poco peculiar dentro del lenguaje C ++ porque usa

etiquetas en vez de bloques. Esto nos obliga a poner instrucciones break
despus del grupo de instrucciones que queremos ejecutar para una condicin
especfica. De no ser asi, las dems instrucciones de las otras constantes hasta el
final de la instruccin Swicht tambin sern ejecutadas
Por ejemplo, si no inclumos una declaracin break despus del primer grupo
para el caso 1, el programa automticamente no brincar al final del interruptor
el bloque selectivo y esto seguira ejecutando el resto de declaraciones hasta que
esto alcance instruccin break o el final del bloque selectivo switch. Esto hace
innecesario de incluir llaves {} encerrando la instrucciones para cada uno de los
casos, y tambin puede ser til ejecutar el mismo bloque de instrucciones para
valores posibles diferentes para la expresin que esta siendo evaluada. Por
ejemplo:

39
Pag
DEV C++
switch (x) {
case 1:
case 2:
case 3:
cout << "x es 1, 2 o 3";
break;
default:
cout << "x no es 1, 2 o 3";
}
Note que el interruptor slo puede ser usado para comparar una expresin contra
constantes. Por lo tanto no podemos poner variables como etiquetas (por
ejemplo case n : donde la n es una variable) o rangos (case (1 .. 3):) porque
ellos no son constantes validas en C ++ .
Si usted tiene que comprobar rangos o los valores que no son constantes, se
usan un anidamiento if..else
Ejercicios Propuestos
1.- Escribe un programa que calcule el sueldo semanal de un empleado, si la
empresa donde trabaja, paga a sus empleados por horas trabajadas
semanalmente, siguiendo las siguientes consideraciones:
Existen dos departamentos, en los que a sus empleados se les pagan las
siguientes cantidades por hora:
1) Contabilidad
6.25 Soles/hora
2) Produccin
2.45 Soles/hora
Adems la empresa otorga a sus empleados un bono por asistencia segn el
reporte de asistencias del ltimo ao
0 (cero) faltas... 18.50 soles adicionales
2 faltas...............
9.00 soles adicionales
3 faltas...............
3.00 soles adicionales
Ms de 3 faltas no recibe bono por asistencia
El programa deber preguntar:
El departamento en que trabaja en el empleado (1 =contabilidad 2
=produccin), el nmero de faltas que tiene en el ltimo ao trabajado y horas
trabajadas por semana.
Despus de pedir esta informacin el programa calcular el sueldo integrado del
empleado, que se obtendr de la siguiente manera:
sueldo_neto= (horas_trabajadas*sueldo_diario)
sueldo_integrado=sueldo_neto+bono_por_asistencia
Finalmente mostrara un reporte como el siguiente:
Sueldo neto......................:xxxxx.xx
Bono por asistencia........:xxxxx.xx
Sueldo integrado..............:xxxxx.xx
2.-Un almacn de alimentos, atendiendo al monto anual que los clientes compran
al almacn, los clasifica y les otorga descuentos permanentes segn la tabla que
40
Pag
DEV C++
se muestra a continuacin:
a.- Cliente Preferente
recibe el 5% de descuento en montos menores a 500.00 soles
recibe el 10% de descuento en montos de 500.00 soles o ms
b.- Cliente especial
recibe el 2% de descuento en montos menores a 500.00 soles
recibe el 5% de descuento en montos de 500.00 soles o ms
c.- Cliente Ordinario
no recibe descuento
El programa deber preguntar la clasificacin del cliente y el monto a pagar,
posteriormente mostrar un reporte como el siguiente:
Monto a pagar...................:xxxxx.xx
Descuento.........................:xxxxx.xx
TOTAL con descuento......:xxxxx.xx
3.-Una empresa familiar de zapatos, fabrica 3 modelos de zapatos para caballero
con los siguientes precios de venta:
1.- Modelo Ejecutivo..........345.50
2.- Modelo Premier............298.70
3.- Modelo Emperador......246.00
Los 3 modelos son fabricados nicamente en talla 8. La empresa planea fabricar
los tres modelos tambin en tallas 9 y 10, y desea un programa que calcule los
precios de venta para estas nuevas tallas. Se sabe que por cada nmero que se
aumente en la talla del zapato, su precio de venta deber incrementarse 10
soles, esto significa que si el modelo Emperador cuesta 246.00 soles en medida
nmero 8, su costo en nmero 9 ser 256.00 y en 10 es 266.00
Escribe un programa que pida el modelo del zapato (a, b c) y la medida (8,9
10) e imprima en pantalla su precio de venta correspondiente.
4.-Una asociacin de asistencia social otorga las siguientes cantidades por
concepto de beca mensual a estudiantes con pobreza extrema y moderada, de
los siguientes 3 niveles:
a) Primaria..................beca bsica=300.00
b) Secundaria.............beca bsica=600.00
c) Preparatoria............beca bsica=900.00
Adicionalmente se suman las siguientes cantidades a la beca bsica dependiendo
del estado de la vivienda en la que habita el estudiante.
1) Su familia vive en casa propia.....= no se incrementa su beca bsica.
2) Su familia renta casa.....................= se suman 100.00 soles a su beca
bsica.
3) Vivienda irregular, sin servicios..= se suman 200.00 soles a su beca bsica.
Escribe un programa que pregunte el nivel del estudiante:
( a)primaria, b)secundaria c)preparatoria)
Pregunte tambin la condicin de la vivienda que el estudiante habita:
(1) casa propia, 2)casa rentada 3)vivienda irregular, sin servicios)
Posteriormente muestre en pantalla el monto total de su beca.
5.-Escribe un programa que muestre nombres propios para hombre o mujer, cuya
41
Pag
DEV C++
primer letra sea una vocal, esto es, el programa deber pedir la Vocal con la que
se desea el nombre (a, e, i, o, u), y preguntar si se desea nombre para hombre o
para mujer (1.- hombre, 2.- mujer), posteriormente mostrar el nombre que
corresponda a esa seleccin, los nombres propuestos son:
Alberto...ngela
Ernesto...Emilia
Ignaciol....Iris
Octavio...Odalis
Ulises....Ursula
Estructuras de Iteracion (lazos)

Los lazos tienen como el objetivo de repetir una declaracin un cierto nmero de
veces o mientras una condicin es realizada
4.3 El lazo while

Su formato es:
while (expresion) instruccin
Su funcionalidad debe simplemente

repetir la declaracin mientras la
condicin puesta en la expresin es
verdadera( distinto de cero).
Por ejemplo, vamos a hacer un programa

con la cuenta regresiva que usa un lazowhile:
Programa # 14
// conteo descendente usando While

#include <iostream>
42
Pag
DEV C++
int main ()
{
int n;
cout << "Ingrese numero inicial > ";
cin >> n;
while (n>0) {
cout << n << ", ";
--n;
}
cout << "FIN\n";
system(pause);
return 0;
}
Ejecucin del programa ;
Ingrese numero inicial > 7

7, 6 , 5 , 4 , 3 , 2 . 1 , FIN
presione una tecla para continuar . .
Cuando el programa comienza pide al usuario ingresar un nmero de partida

para la cuenta regresiva. Entonces el lazo while comienza, si el valor ingresado
por el usuario cumple con la condicin n> 0 ( n es mayor cero) el bloque que
sigue a la condicin ser ejecutada y repetida mientras la condicin (n > 0) siga
siendo verdadera
El proceso total del programa anterior puede ser interpretado segn la secuencia
siguiente (comenzando en main ):
1.
El usuario asigna un valor a n
2.
La condicion while es evaluada (n>0). En este punto hay dos posibilidades :

* La condicion es verdadera : La instruccion es ejecutada ( ir al paso 3)
* la condicion es falsa : ignorar instruccin y continuar (ir al paso 5)
Ejecutar instruccion:
3.
cout << n << ", ";

--n;
4.
(imprime el valor de n en la pantalla y decrementa el valor de n en 1)

Fin del bloque . Regresar automaticamente al paso 2
Continuar el programa despus del bloque : Imprimir FIN y terminar el programa.
Cuando creamos un lazo While , siempre debemos considerar que tiene que
terminarse en algn punto, por lo tanto debemos proporcionar dentro del bloque
algn mtodo de obligar a la condicin de hacerse falsos en algn punto, si no el
lazo seguir infinitamente. En este caso hemos incluido - la n; que disminuye el
valor de la variable que es evaluada en la condicin (n) en cada iteracin , hasta
que el valor de n se hace cero y por tanto la condicin sea falsa terminando el
lazo.
43
Pag
DEV C++
Desde luego esto es una accin tan simple para nuestro ordenador que la cuenta
regresiva entera es realizada al instante y sin demora .
Ejercicios Propuestos
1 - Realizar un programa que imprima 25 trminos de la serie 11 - 22 - 33 - 44,
etc. (No se ingresan valores por teclado).
2 - Mostrar los mltiplos de 8 hasta el valor 500. Debe aparecer en pantalla 8 -16
-24, etc.
3 - Escribir un programa que lea 10 notas de alumnos y nos informe cuntos
tienen notas mayores o iguales a 11 y cuntos menores.
4 - Se ingresan un conjunto de 5 alturas de personas por teclado. Mostrar la
altura promedio de las personas
5 - En una empresa trabajan 5 empleados cuyos sueldos oscilan entre $100 y
$500, realizar un programa que lea los sueldos que cobra cada empleado e
informe cuntos empleados cobran entre $100 y $300 y cuntos cobran ms de
$300. Adems el programa deber informar el importe que gasta la empresa en
sueldos al personal.
6 - Desarrollar un programa que permita cargar 5 nmeros enteros y luego nos
informe cuntos valores fueron pares y cuntos impares.
Emplear el operador "%" en la condicin de la estructura condicional
if (valor%2==0)
El operador "%" retorna el resto de la divisin valor / 2. Por ejemplo: 12 % 2,
retorna 0; 13 % 2, retorna 1, porque el resto de dividir 13 en 2 es 1.
4.4 El lazo do-while

Su formato es :
do instruccin
while (condicion);
Su funcionalidad es exactamente la misma

que el lazo WHILE ,
con la excepcin
que en el do-while la condicin es evaluada
despus de la ejecucin de la instruccin ,
permitiendo al menos una ejecucin de la
instruccin incluso si la condicin fuese falsa
. Por ejemplo, el programa de ejemplo
44
Pag
DEV C++
siguiente repite cualquier nmero en el que usted ingrese hasta que usted
ingrese 0
Programa # 15
#include <iostream>
int main ()
{
unsigned long n;
do {
cout << "Ingrese un numero (0 para terminar): ";
cin >> n;
cout << "Ha ingresado: " << n << "\n";
} while (n != 0);
system(pause);
return 0;
}
Ingrese un numero (0 para terminar ) :

Ha ingresado 12
Ingrese un numero (0 para terminar ) :
Ha ingresado 0
12
0
Presione cualquier tecla para continuar. . .

Programas Propuestos
1 - Realizar un programa que acumule (sume) valores ingresados por teclado hasta ingresa el 9999
(no sumar dicho valor, solamente indica que ha finalizado la carga). Imprimir el valor acumulado e
informar si dicho valor es cero, mayor a cero o menor a cero
En un banco se procesan datos de las cuentas corrientes de sus clientes. De cada cuenta corriente se
conoce: nmero de cuenta, nombre del cliente y saldo actual. El ingreso de datos debe finalizar al
ingresar un valor negativo en el nmero de cuenta.
Se pide confeccionar un programa que lea los datos de las cuentas corrientes e informe:
a) De cada cuenta: nmero de cuenta, nombre del cliente y estado de la cuenta segn su saldo,
sabiendo que:
Estado de la cuenta `Acreedor si el saldo es < 0
'Deudor' si el saldo es <0

'Nulo' si el saldo es =0.
b) La suma total de los saldos acreedores.
3 - Se realiz un censo provincial y se desea procesar la informacin obtenida en dicho censo. De
cada una de las personas censadas se tiene la siguiente informacin: nmero de documento, edad y
sexo ('femenino' o 'masculino')
Se pide confeccionar un programa que lea los datos de cada persona censada (para finalizar ingresar
el valor cero en el nmero de documento) e informar:
a)
b)
Cantidad total de personas censadas.

Cantidad de varones.

45
Pag
c)
DEV C++
Cantidad de mujeres.
4.5 El lazo For

Su formato es :
for (inicializacin; condicin; incremento) instruccin;
Y su principal
funcin es
repetir la
declaracin
mientras
la
condicin
sea
verdadera, como en
el lazo while . Pero
adems, el lazo for proporciona posiciones
especficas para contener una declaracin de
inicializacin y una declaracin de incremento.
Entonces este lazo sobre todo es diseado
para realizar una accin repetidora con un
contador que es inicializado e incrementado
sobre cada iteracin
La forma de trabajar es como sigue :.

1. La inicializacin es ejecutada. Generalmente
es un valor inicial que se pone para una
variable contadora . Esto es ejecutado slo
una vez
2. La condicin es evaluada. Si es verdadera el

lazo sigue, si no los finales de lazo y la
instruccin son salteados (no ejecutado).

46
Pag
DEV C++
3. La instruccion es ejecutada. Pudiendo ser una o un bloque delimitado entre

llaves {}.
4. Finalmente, independientemente de lo especificado en el campo de
incremento es ejecutado y el lazo regresa al paso 2.
Veremos un ejemplo de cuenta descendente usando un lazo for:
Programa # 16
// conteo descendente usando for

#include <iostream>
int main ()
{
for (int n=10; n>0; n--) {
cout << n << ", ";
}
cout << "FIN!\n";
system(pause);
return 0;
}
10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIN!
La inicializacin y el campo de incremento

son opcionales. Ellos pueden
permanecer vacos, pero en todos los casos los signos de punto y coma entre
ellos deben ser escritos. Por ejemplo nosotros podramos escribir: para (; n <
10;) si quisiramos especificar ninguna inicializacin y ningn aumento; o para (;
n < 10; n ++) si quisiramos incluir un campo de incremento, pero ninguna
inicializacin (tal vez porque la variable ya fue inicializada antes).
Opcionalmente, usando al operador de coma (,) podemos especificar ms que
una expresin en cualquiera de los campos incluidos en un para el lazo, como en
la inicializacin, por ejemplo. El operador de coma (,) es un separador de
expresin, esto sirve para separarse ms que una expresin donde slo una es
esperada. Por ejemplo, suponga que quisimos inicializar ms que una variable en
nuestro lazo
for ( n=0, i=100 ; n!=i ; n++, i-- )

{
// instrucciones...
}
Este lazo se ejecutar 50 veces si n o i son modificados dentro del lazo:

47
Pag
DEV C++
n comienza con un valor de 0, y con 100, la condicin n! =i ( n no es igual a i).

Como la n es aumentada en uno y la i es disminuido uno, la condicin del lazo
se hara falso despus del 50 iteraciones , cuando tanto la n como i sean iguales
a 50.
Ejercicios Propuestos:
1 - Desarrollar un programa que solicite la carga de 10 nmeros e imprima la
suma de lo ltimos 5 valores ingresados.
2- Desarrollar un programa que muestre la tabla de multiplicar del 5 (del 5 al
50).
3 - Confeccionar un programa que permita ingresar un valor del 1 al 10 y nos
muestre la tabla de multiplicar del mismo (los primeros 12 trminos)
Ejemplo: Si ingreso 3 deber aparecer en pantalla los valores 3, 6, 9, hasta el
36.
4 - Realizar un programa que lea los lados de 4 tringulos, e informar: a) De
cada uno de ellos, qu tipo de tringulo es: equiltero (tres lados iguales),
issceles (dos lados iguales), o escaleno (ningn lado igual)
b) Cantidad de tringulos de cada tipo.
c) Tipo de tringulo del que hay menor cantidad.
5 - Se realiza la carga de 10 valores enteros por teclado. Se desea conocer:
a) La cantidad de valores negativos ingresados.
b) La cantidad de valores positivos ingresados.
c) La cantidad de mltiplos de 15.
d) El valor acumulado de los nmeros ingresados que son pares.
6 - Se cuenta con la siguiente informacin:
Las edades de 50 estudiantes del turno maana.
Las edades de 60 estudiantes del turno tarde.
Las edades de 110 estudiantes del turno noche.
Las edades de cada estudiante deben ingresarse por teclado.
a) Obtener el promedio de las edades de cada turno (tres promedios).
b) Imprimir dichos promedios (promedio de cada turno).
c) Mostrar por pantalla un mensaje que indique cual de los tres turnos tiene un
promedio de edades mayor
7.Resolver la Ecuacin X2
+ Y
= Z2
Para valores de X , Y , Z que varian desde 1 a 25

48
Pag
DEV C++
4.6 La instruccion break

Usando Break podemos interrumpir la ejecucin de un lazo incluso si la condicin
for no es verdadera . Esto puede ser usado para terminar un lazo infinito, y
obligarlo a terminar antes de su finalizacin normal. Por ejemplo, vamos a
parar el conteo descendente antes de su final normal (tal vez debido a un error
de comprobacin de la maquina?):
Programa # 17
// ejemplo de uso de break
#include <iostream>
int main ()
{
int n;
for (n=10; n>0; n--)
{
cout << n << ", ";
if (n==3)
{
cout << ". . .contador interrumpido!\n";
break;
}
}system(pause);
return 0;
}
Ejecucion del programa:

10, 9, 8, 7, 6, 5, 4,3 . . . contador interrumpido !
Presione una tecla para continuar.

49
Pag
DEV C++
4.7 Instruccion continue

La instruccin hace que el programa salte las instrucciones siguientes del lazo
como si el final del bloque hubiese sido alcanzado, ocasionando que se regrese
al inicio de la iteracin siguiente . Por ejemplo, vamos a saltar el nmero 5 en
nuestra cuenta regresiva:
Programa # 17
// ejemplo de la instruccion CONTINUE

#include <iostream>
int main ()
{
for (int n=10; n>0; n--) {
if (n==5) continue;
cout << n << ", ";
}
cout << "FIN!\n";
system(pause);
return 0;
}

10, 9, 8, 7, 6, 4, 3, 2, 1, FIN!
Presione una tecla para continuar
4.8 La instruccion goto

Goto permite hacer un salto absoluto a otro punto en el programa. debera
usarse con precaucin ya que su ejecucin causa un salto incondicional
ignorando cualquier tipo de limitaciones cercanas.
El punto de destino es identificado por una etiqueta, que es usada como un
argumento para la instruccin goto. Una etiqueta es hecha de un identificador
vlido seguido de un doble punto (:).
Por lo general, esta instruccin no tiene ningn empleo concreto en programacin
estructurada u orientada a objetos aparte de aquellos de lo que los aficinados a
los programas de bajo nivel pueden encontrar para ello. Por ejemplo, aqu est
nuestro lazo de cuenta regresiva que usa goto
Programa # 18
// goto uso del goto

#include <iostream>
int main ()
{
50
Pag
DEV C++
int n=10;
lazo:
cout << n << ", ";
n--;
if (n>0) goto lazo;
cout << "FIN!\n";
system(pause);
return 0;
}

10, 9, 8, 7, 6, 5, 4, 3, 2, 1, FIN
presione una tecla para continuar. . .

51
Pag

Guia C++

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guia C++

Cargado por

Copyright:

Formatos disponibles

LENGUAJE DE PROGRAMACION I

Ing. JAVIER ECHEGARAY ROJO

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

CAPTULO 1 INTRODUCCIN AL LENGUAJE C++...................................3

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

CAPTULO 1 INTRODUCCIN AL LENGUAJE C++

1.1 ESTRUCTURA BSICA DE UN PROGRAMA

1.2 COMO USAR DEV C++

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

A continuacin nos aparecer LA VENTANA DE EDICION DE CODIGO, donde se

En caso de que algo exista

Cuando esta libre de errores la

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

Como resultado obtendremos;

Analicemos cada parte de nuestro primer programa.

using namespace std;

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

programa. Adems podr encontrar el uso de /* */ estos caracteres encierran

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

VARIABLES .TIPOS DE DATOS EN C++

2.1 Identificador, definicin

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

2.3 TIPOS DE DATOS FUNDAMENTALES

Carcter o pequeos enteros .

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

4bytes signed: -2147483648

Valor Booleano. Puede tomar 2

Numero de punto flotante

4bytes 3.4e +/- 38 (7 digits)

Numero de punto flotante doble

8bytes 1.7e +/- 308 (15 digits)

long double Numero largo de punto flotante

8bytes 1.7e +/- 308 (15 digits)

En un programa puede que necesitemos declarar un dato y asignarle un nombre,

Por ejemplo, el siguiente programa calcula el rea de un crculo.

Otro modo de inicializar variables se realiza incluyendo el valor inicial entre

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

Ejecucin del programa:

Las constantes son expresiones con un valor que permanece fijo.

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

Todos estos representan el mismo nmero: 75 (setenta y cinco) expresado como

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

En ambos casos, el sufijo puede ser especificado usando letras maysculas o

2.9 Nmeros de Punto flotante

Cualquiera de las letras pueden ser de una constante numrica de punto

2.10 Caracter y cadena de caracteres

Tambin existen constantes no numricas , como:

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

Escribiendo tanto el carcter simples como las cadenas de caracteres , es

Las cadenas de caracteres

2.12 Constantes definidas (#define)

// constantes definidas : calcula rea del circulo

Ejecucion del programa :

clave, los operadores en C ++ mayormente son hechas de los signos que no

cout << b<<endl;

Presione cualquier tecla para continuar . . .

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

Las operaciones de adicin, substraccin, multiplicacin y divisin literalmente

valor = valor + incremento;

precio *= unidad + 1; precio = precio * (unidad + 1);

// Operadores de asignacion compuestos

2.14.4 Incremento y decremento(++, --)

Ing. Javier Echegaray Rojo / Ing. Wilder Romn Munive

precio = unidad + 1; precio = precio (unidad + 1);