Está en la página 1de 24

APUNTES DE LENGUAJE C++ By Charly D.R.C.

COUT << "ONE";


COUT << "TWO";
COUT << "THREEE";

SE PODRIA ESCRIBIR ASI:

COUT << "ONE" << "TWO" << "THREE";

--------------------------------------------------

COUT << "THE VALUE OF NUM IS: ";


COUT << NUM;

SE PODRIA ESCRIBIR ASI:

COUT << "THE VALUE OF NUM IS: " << NUM;

--------------------------------------------------

DECLARAR VARIABLES

INT CONTADOR, CANTIDAD, I, J, K;

--------------------------------------------------

INTRODUCIR VALORES

CIN >> NUM;

CIN >> A >> B; // INTRODUCE DOS VALORES

--------------------------------------------------
PUTO Y COMA LA SINTAXIS Y EL TABULADO

X = Y;
Y = Y+1;

ES LO MISMO QUE

COUT << X * Y;

--------------------------------------------------

FUNCIONES

LA FUNCION ES UNA SUBRRUTINA QUE CONTIENE UNA O MAS SENTENCIAS


DE C++ Y EFECTUA UNA TAREA DETERMINADA.

CADA FUNCION TIENE UN NOMBRE Y ESTE MISMO ES EL QUE SE USA PARA


EJECUTARLA.

EN C++ UNA FUNCION NO PUEDE SER CREADA DE NTRO DE OTRA FUNCION.

UNA FUNCION PUEDE LLAMAR A OTRA.

#INCLUDE <IOSTREAM.H>
VOID MIFUN(); // PROTOTIPO DE MIFUN()

MAIN()

{
XXXXX;
XXXXX;
RETUN 0;

VOID MIFUN()

{
XXXXX;
XXXXX;
RETURN 0;

EN ESTE CASO LA FUNCION ES DECLARADA ANTES DE MAIN() ESTO ES PORQUE


ES UNA FUNCION PROTOTIPO.

EL PROTOTIPO DE UNA FUNCION PERMITE AL COMPILADOR SABER EL TIPO QUE


DEVUELVE Y EL NUMERO Y TIPOS DE PARAMETROS QU E PUEDE TENER LA FUNCION.

EL COMPILADOR NECESITA TENER ESTA INFORMACION ANTES DE QUE LA FUNCION


SEA LLAMADA POR PRIMERA VEZ.

ESTO SE DEBE QUE LOS PROTOTIPOS APAREZCAN ANTES QUE MAIN().

LAS FUNCIONES QUE NO DEVUELVEN NINGUN VALOR SON DECLARADAS COMO VOID.

--------------------------------------------------

ARGUMENTOS DE FUNCIONES

SE PUEDE PASAR UNO O MAS VALORES A UNA FUNCION.

EL VALOR QUE SE PASA A UNA FUNCION SE LLAMA ARGUMENTO.

LAS FUNCIONES PUEDEN TENER DESDE CERO A VARIOS ARGUMENTOS.

PERO AL MENOS SE PERMITIRAN 256 ARGUMENTOS EN CUALQUIER


COMPILADOR ESTANDAR.

ESTE ES UN BREVE PROGRAMA QUE USA UNA DE LAS FUNCIONES DE


LA BIBLIOTECA ESTANDAR DE C++ LLAMADA ABS(),PARA MOSTRAR EL
VALOR ABSOLUTO DE UN NUMERO.

LA FUNCION ABS() ACEPTA UN ARGUMENTO, LO CONVIERTE EN SU VALOR


ABSOLUTO Y DEVUELVE EL RESULTADO.

#INCLUDE <IOSTREAM.H>
#INCLUDE <STDLIB.H>

MAIN()
{
COUT << ABS(-10)

RETURN 0;

DEVOLVERA EL VALOR 10.

AL CREAR UNA FUNCION QUE ACEPTA UNO O MAS ARGUMENTOS,


LAS VARIABLES QUE VAN A RECIBIR ESTOS ARGUMENTOS TAMBIEN
DEBEN SER DECLARADAS.ESTOS SE LAMAN PARAMETROS DE LA FUNCION.
LOS PARAMETROS DE UNA FUNCION SE DECLARAN DENTRO DEL PARENTESIS
QUE VIENE DETRAS DE SU NOMBRE.

#INCLUDE <IOSTREAM.H>;

VOID AREAOFTRIANGLE(INT BASE, INT ALTURA);

MAIN()

AREAOFTRIANGLE (10, 20);


AREAOFTRIANGLE (10, 20);
AREAOFTRIANGLE (10, 20);

RETURN0;

VOID AREAOFTRIANGLE(INT BASE, INT ALTURA)

COUT << "AREA OF TRIANGLE IS ";


COUT << BASE * ALTURA / 2;
COUT << "/N";

}
CADA VEZ QUE ES LLAMADA AREAOFTRIANGLE(), MOSTRARA EL AREA DEL
TRIANGULO CUYA BASE ES PASADA COMO PRIMER ARGUMENTO Y CUYA ALTURA
ES PASADA EN EL SEGUNDO ARGUMENTO.

TOMA NOTA DE QUE LOS APRAMETRO DE AREAOFTRIANGLE() TAMBIEN ESTAN


DECLARADOS EN EL PROTOTIPO.CUANDOI SE CREA EL PROTOTIPO DE UNA FUNCION,
DEBE INCLUIR LA DECLARACION DE CUALESQUIERA PARAMETROS QUE USE LA FUNCION.

EL TERMINO ARGUMENTO SE REFIERE AL VALOR QUE SE USA PARA LLAMAR A UNA FUNCION.

LA VARIABLE QUE RECIBE EL VALOR DE UN ARGUMENTO SE LLAMA PARAMETRO.

LA FUNCIONES QUE ACEPTAN ARGUMENTOS SE LLAMAN FUNCIONES CON PARAMERTROS.

--------------------------------------------------

FUNCIONES QUE DEVUELVEN VALORES

MUCHAS FUNCIONES DE LA BIBLIOTECA DE C++QUE UTILIZARA DEVUELVEN UN VALOR.


VAMOS A ILUSTRAR FUNCIONES QUE DEVUELVEN VALORES.

#INCLUDE <IOSTREAM.H>;

INT AREAOFTRIANGLE(INT BASE, INT ALTURA);

MAIN()

INT AREA;

AREA = AREAOFTRIANGLE(9, 12);// ASIGNA EL VALOR DEVUELTO


COUT << "THE AREA IS " << AREA;

RETURN 0;

iNT AREAOFTRIANGLE(INT BASE, INT ALTURA)


{

RETURN BASE * ALTURA / 2;

EN ESTE EJEMPLO, AREAOFTRIANGLE() DEVUELVE EL VALOR BASE * ALTURA / 2


USANDO LA SENTENCIA RETURN.ESTE VALOR ES ENTONCES ASIGNADO A AREA.
ESTO ES, EL VALOR DEVUELTO POR LA SENTENCIA RETURN PASA A SER EL VALOR
DE AREAOFTRIANGLE() EN LA RUTINA QUE LLAMA.

COMO AREAOFTRIANGLE() AHORA DEVUELVE UN VALOR, NO ESTA PRECEDIDA DE LA


PALABRA RESERVADA VOID.(RECORDEMOS QUE VOID SOLAMENTE SE USA CUANDO UNA
FUNCION NO DEVUELVE UN VALOR).

EN SU LUGAR ESTA PRECEDIADA POR EL TIPO INT.


ASI COMO HAY DISTINTOS TIPOS DE VARIABLES TAMBIEN HAY DISTINTOS TIPOS
DE VALORES DE DEVOLUCION.
EN ESTE CASO, AREAOFTRIANGLE() DEVUELVE DATOS DE TIPO ENTERO.EL TIPO
QUE DEVUELVE UNA FUNCION PRECEDE A SU NOMBRE TANTO EN SU PROTOTIPO
COMO EN SU DEFINICION.

AL DECLARAR UNA FUNCION, SI NO ESPECIFICA UN TIPO DE DEVOLUCION,


ENTONCES SE ASUME QUE LA FUNCION DEVUELVE UN VALOR ENTERO.

POR EJEMPLO, LA FUNCION AREAOFTRIANGLE()


QUE SE ACABA DE MOSTRAR, SE PODRIA ESCRIBIR ASI:

AREAOFTRIANGLE(INT BASE, INT ALTURA)

RETURN BASE * ALTURA / 2;

--------------------------------------------------
SENTENCIAS DE CONTROL

IF:

LA SENTENCIA IF ES UNA DE LAS SENTENCIAS DE SELECCION DE C++.

IF (EXPRESION) SENTENCIA;

SI ES TRUE SE EJECUTARA, SI NO ES ASI LA SENTENCIA SERA OMITIDA


Y SE EJECUTARA LA LINEA DE CODIGO QUE VIENE DETRAS DE LA SENTENCIA IF.

EN C++ UNA EXPRESION ES VERDADERA (TRUE) SI SU EVALUACION RESULTA EN


UN VALOR DISTINTO DE CERO.

SI SU EVALUACION RESULTA EN EL VALOR CERO, ENTONCES ES FALSA (FALSE).

IF (10 > 9) COUT << "TRUE";

SI 10 ES MAYOR QUE CERO, ENTONCES SE IMPRIMIRA (TRUE).

IF (3 > 11) COUT << "ESTO NO SE IMPRIMIRA";

SI 3 MAYOR QUE 11, COMO NO ES MAYOR NO SE IMPRIMIRA (FALSE).

--------------------------------------------------

ELSE

IF (EXPRESION) SENTENCIA1;
ELSE SENTENCIA2;

SI LA EXPRESION ES TRUE, ENTONCES SE EJECUTARA LA SENTNECIA1 Y SE


SALTARA LA PORCION ELSE.

SI LA EXPRESION ES FALSE, ENTONCES SE OMITIRA LA SENTENCIA1 Y SE EJECUTARA


LA SENTENCIA 2.

--------------------------------------------------

BLOQUES DE CODIGO

SE CREAN PONIENDO LAS SENTENCIAS ENTRE LLAVES.

IF (COUNTER > 100) {

COUT <<< "DEMASIADO GRANDE: INTRODUZCA OTRO NUNMERO";


CIN << COUNTER;
}

UN BLOQUE DE CODIGO ENPIEZA EN { Y TERMINA EN }.

UN BLOQUE DE CODIGO PUEDE SER ANIDADO DENTRO DE OTRO BLOQUE.

LOS BLOQUES PUEDEN SER ANIDADOS HATA ALMENOS 256 NIVELES.

--------------------------------------------------

SENTENCIA IF ANIDADAS
CUANDO UNA SENTENCIA IF ES EL OBJETIVO DE OTRO IF O ELSE, SE DICE
QUE ESTA ANIDADO DENTRO DEL IF EXTERIOR.

IF (COUNT > MAX) // IF EXTERIOR

IF (ERROR == 26) COUT << "ERROR, INTNENTAR DE NUEVAMENTE."; // IF ANIDADO

UN IF ANIDADO TAMBIEN SE CREA CUANDO UN IF APARECE DENTRO DE UN BLOQUE DE


SENTENCIAS QUE SON EL OBJETIVO DEL IF EXTERIOR.

IF (COUNT > MAX) { // IF EXTERIOR

MAX = COUNT;

IF (ERROR == 26) COUT << "ERROR, INTNENTAR DE NUEVAMENTE."; // IF ANIDADO


COUNT = COUNT + 3;

UN ASPECTO CONFUSO DE LOS IF ANIDADOS SE ILUSTRA EN EL SIGUIENTE FRAGMENTO.

IF (P < 10)

IF (Q < 100) COUT "AMBAS SENTENCIAS IF SON CIERTAS";


ELSE COUT << "A QUE SENTENCIA IF SE APLICA ESTE ELSE?";

LA RESPUESTA ES MUY SENCILLA: UN ELSE SIEMPRE SE ASOCIA CON EL IF MAS PROXIMO


DENTRO DEL MISMO BLOQUE QUE NO ESTE AUN ASOCIADO A UN ELSE.

EN EL EJEMPLO, EL ELSE ESTA ASOCIADO CON EL SEGUNDO IF.

ES POSIBLE CONCATENAR VARIAS SENTENCIAS IF Y ELSE.

IF (EXPRESION)
SENTENCIA;
ELSE IF (EXPRESION)
SENTENCIA;
ELSE IF (EXPRESION)
SENTENCIA;
.
.
.
ELSE
SENTENCIA;

--------------------------------------------------

OPERADORES RELACIONALES Y LOGICOS

DE RELACION

> MAYOR QUE


>= MAYOR QUE O IGUAL
> MENOR QUE
>= MENOR QUE O IGUAL
== IGUAL
!= NO IGUAL

LOGICOS
LA TABLA USA 1 COMO TRUE Y 0 COMO FALSE.

&& AND
|| OR
! NOT

1=TRUE
0=FALSE

P Q P-AND-Q P-ORQ NOT-P

O O O O 1
0 1 0 1 1
1 1 1 1 0
1 0 0 1 0

AUNQUE C++ NO INCORPORA UN OPERADOR OR EXCLUSIVO, ES FACIL CONSTRUIR UNO.


EL OPERADOR XOR USA ESTA TABLA:

P Q P-XOR-Q

0 0 0
0 1 1
1 0 1
1 1 0

DICHO EN PALABRAS, LA OPERACION XOR PRODUCE UN RESULTADO QUE ES TRUE CUANDO


UNO Y SOLO UNO DE LOS OPERANDOS ES TRUE.

LA SIGUIENTE FUNCION USA LOS OPERADORES &&, || Y ! PARA CONSTRUIR UNA


OPERACION XOR, CUYO RESULTADO ES DEVUELTO POR LA FUNCION.

XOR(INT A, INT B)
{
RETURN (A || B) && ! (A && B);
}

LA TABLA SIGIENTE MUESTRA LA PRECEDENCIA RELATIVA DE LOS OPERDORES


RELACIONLAES Y LOGICOS.

MAS ALTA !
> >= < <=
== !=
&&
MAS BAJA ||

TODAS LA EXPRESIONES RELACIONALES Y LOGICAS GENERAN UN RESULTADO


QUE ES VERDADERO O FALSO.GENERALMENTE, EL VALOR 1 ES VERDADERO (TRUE)
Y 0 FALSO (FALSE).

EL SIGUIENTE PROGRAMA IMPRIMIRA EL NUMERO 1 EN PANTALLA.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT X;
X = 100;
COUT << (X > 100);

RETURN 0;+
}

--------------------------------------------------

COMPROBACION DE CERO

ESTA ES LA FORMA DE PRINCIPIANTE.

IF (SIZE == 0) COUT << "SIZE ES IGUAL A CERO";

ESTA ES LA FORMA PROFESIONAL.

IF (!SIZE) COUT << "SIZE ES IGUAL A CERO";

SI SIZE ES CERO, ENTONCES !SIZE ES TRUE.

SI SIZE ES DISTINTO DE CERO, ENTONCES !SIZE ES FALSE.

LA COMPROBACION DE DISTINTO DE CERO (VERDADERO) TAMBIEN SE EFECTUA DE LA


MISMA FORMA.

ESTA ES LA FORMA DE PRINCIPIANTE.

IF (ERROR != 0) COUT >> "SE HA PRODUCIDO UN ERROR";

ESTA ES LA FORMA PROFESIONAL.

IF (ERROR) >> "SE HA PRODUCIDO UN ERROR";

LA SENTENCIA COUT SE EJECUTARA SI Y SOLO SI LA VARIABLE ERROR ES DISTINTA


DE CERO.

--------------------------------------------------

LA SENTENCIA SWITCH

MIENTRA QUE IF ES BUENO PARA ESCOGER ENTRE DOS ALTERNATIVAS,


SE HACE RAPIDAMENTE INCOMODO CUANDO SE NECESITANS VARIAS ALTERNATIVAS.

LA SENTENCIA SWITCH ES LA SENTENCIA DE SELECCION MULTIPLE DE C++.

UNA VARIABLE SE COMPARA DE FORMA SUCESIVA CON UNA LISTA DE CONSTANTES


ENTERAS O DE CARACTER.

SWITCH (VARIABLE){

CASE CONSTANTE 1:
SECUENCIA DE SENTENCIAS
BREAK;
CASE CONSTANTE 2:
SECUENCIA DE SENTENCIAS
BREAK;
CASE CONSTANTE 3:
SECUENCIA DE SENTENCIAS
BREAK;
.
.
.
DEFAULT:

SECUENCIA DE SENTENCIAS
}

LA SECUENCIA DEFAULT SE EFECTUARA SI NO SE ENCUENTRA COINCIDENCIAS.

LA SENTENCIA DEFAULT ES OPCIONAL.

SI TODAS LA COINCIDENCIAS FALLAN Y NO HAY SENTENCIA DEFAULT, NO HABRA


NINGUNA ACCION.

UNA VEZ QUE SE ENCUENTRA UNA COINCIDENCIA, SE EJECUTARA LA SECUENCIA DE


SENTENCIAS HASTA QUE SE ENCUENTRE LA SENTENCIA BREAK, O EN CASO DE DEFAULT
O EN EL ULTIMO CASE, SE LLEGA AL FINAL DEL SWITCH.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT I;

COUT << "INTRODUZCA UN NUMERO ENTRE 1 Y 2.";


CIN >> I;

SWITCH (I) {
CASE 1:
COUT << "UNO";
BREAK;
CASE 2:
COUT << "DOS";
BREAK;

DEFAULT:
COUT << "NUMERO NO ACEPTADO"
}

RETURN 0;

LA SENTENCIA SWITCH SE DIFERENCIA DE IF EN QUE SWITCH SOLAMENTE PUEDE


COMPROBAR IGUALDAD, MIENTRAS QUE LA EXPRESION CONDICIONAL DE IF PUEDE
SER DE CUALQUIER TIPO.

ADEMAS SWITCH SOLAMENTE FUNCIONA CON TIPOS ENTERO O CARACTER. NO PUEDE


USAR NUMEROS FLOTANTES.

LA SECUENCIAS DE SENTENCIAS QUE ESTAN ASOCIADAS CON CADA CASE NO


FORMAN UN BLOQUE DE CODIGO: NO VAN ENCERRADAS ENTRE LLAVES.

C++ PERMITE ALMENOS 16384 SENTENCIAS CASE DENTRO DE CUALQUIER UNICO SWITCH.

NINGUN PAR DE CONTANTES CASE QUE PERTENEZCAN AL MISMO SWITCH PUEDEN TENER
VALORES IDENTICOS.

ES POSIBLE TENER SWITCHS ANIDADOS.

SI LAS CONTANTES CASE DEL SWITCH INTERIOR Y EXTERIOR CONTIENEN VALORES


COMUNES NO PRESENTARAN CONFLICTOS.

EJEMPLO:

SWITCH (A) {
CASE 1:
SWITCH (B) {
CASE 0: COUT << "B ES FALSO";
BREAK;
CASE 1: COUT << "B ES CIERTO";
}
BREAK;
CASE 2:
.
.
.

C++ PERMITE AL MENOS 256 NIVELES DE ANIDACION DE SENTENCIAS SWITCH.

LA SENTENCIA BREAK ES OPCIONAL, CUANDO APARECE DENTRO DE UN SWITCH


HACE QUE EL FLUJO DEL PROGRAMA SALGA DE TODA LA SENTENCIA SWITCH
Y PROSIGA EN LA SENTENCIA SIGUIENTE A ESTA.

PERO SI SE OMITE LA SENTENCIA BREAK LA EJECUCION CONTINUARA EN EL


SIGUIENTE CASE O EN DEFAULT (SI UNO O OTRO EXISTE).

ES DECIR, CUANDO FALTA LA SENTENCIA BREAK LA EJECUCION PASA DE LARGO


AL SIGUIENTE CASE Y SOLAMENTE SE DETIENE EN UNA SENTENCIA BREAK
SUBSIGUIENTE O CUANDO SE LLEGA AL FINAL DE SWITCH.

LA SECUENCIA DE SENTNECIAS QUE ESTA ASOCIADA CON UN CASE PUEDE


ESTAR VACIA.

ESTO PERMITE QUE DOS O MAS SENTENCIAS CASE COMPARTAN UNA SECUENCIA DE
SENTENCIAS COMUN SIN DUPLICACION DE CODIGO.

EJEMPLO:

#INCLUDE <IOSTREAM.H>

MAIN()

{
CHAR CH;

COUT << "INTRODUZCA UNA LETRA:;


CIN >> CH;

SWITCH (CH) {
CASE 'A':
CASE 'E':
CASE 'I':
CASE 'O':
CASE 'U':
COUT << "ES UNA VOCAL";
BREAK;
DEFAULT:
COUT << "ES UNA CONSONANTE";
}

RETURN 0;

--------------------------------------------------

EL BUCLE FOR

EL BUCLE FOR ES UNA DE LAS TRES SENTENCIAS DE BUCLE DE C++.

PERMITE QUE UNA O MAS SENTENCIAS SE REPITAN.

FOR (INICIALIZACION, ESPRESION, INCREMENTO) SENTENCIA;

PRIMERO SE INICIALIZA LA VARIABLE QUE CONTROLA EL BUCLE.

LA EXPRESION COMPRUEBA LA CONDICION SI ES TRUE EL BUCLE SE REPETIRA SI


NO ES TRUE ENTONCES SALDRA DEL BUCLE.

DESPUES SE INCREMENTA LA VARIABLE DE INICIALIZACION.

EJEMPLO:

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT NUM;

FOR (NUM = 1; NUM < 11; NUM = NUM + 1) COUT << NUM " ";

RETURN 0;

ESTE PROGRAM GENERA LA SIGUIENTE SALIDA.

1 2 3 4 5 6 7 8 9 10

PARA REPETIR VARIAS SENTENCIAS, USE UN BLOQUE DE CODIGO.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT NUM, SUM PROD;

SUM = 0;
PROD = 1;
FOR (NUM = 1; NUM < 11; NUM = NUM + 1) {
SUM = SUM + NUM;
PROD = PROD * NUM;
}

COUT << "PRODUCTO Y SUMA: " << PROD << " " << SUM;

RETURN 0;

UN BUCLE FOR PUEDE EJECUTARSE EN SENTIDO NEGATIVO.

FOR (NUM = 20;NUM < 20; NUM = NUM - 1) ......

ADEMAS LA VARIABLE CONTROL PUEDE SER INCREMENTADA O DECREMENTADA


EN MAS DE UNO.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT I;

FOR (I = 0; I < 60; I = I + 5) COUT << 1996 + I << "/N";

RETURN 0;

--------------------------------------------------

OPERADORES DE INCREMENTO Y DECREMENTO

FOR (NUM = 0; NUM < ALGUN_VALOR; NUM = NUM + 1) ...

AUNQUE NO ES INCORRECTO ES MEJOR UTILIZAR UN OPERADOR DE INCREMENTO O


DECREMENTO.

I = I + 1;

POR

I++;

POR LO TANTO, EL FOR MOSTRADO ANTERIORMENTE SE ESCRIBIRIA NORMALMENTE ASI.

FOR (NUM = 0; NUM < ALGUN_VALOR; NUM++) ...

DE FORMA SIMILAR PARA DISMINUIR UNA VARIABLE.

COUNT = COUNT - 1;

SE PUEDE REESCRIBIR COMO.

COUNT--;

LOS OPERADORES INCREMENTO Y DECREMENTO NO NECESITAN IR DETRAS DE LAS


VARIABLES: LA PUEDEN PRECEDER.

AUNQUE EL EFECTO SOBRE LA VARIABLE ES EL MISMO, LA POSICION DEL OPERADOR


DETERMINA SI EL VALOR DE LA VARIABLE QUE SE TOMA ES EL DE ANTES O DESPUES
DE PRODUCIRSE LA OPERACION. PARA VER COMO, EXAMINE ESTE PROGRAMA.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT I,J;

I = 10;
J = I++;

// ESTO IMPRIMIRA 11 10

COUT << "I Y J: " << I << " " << J;

RETURN 0;

EN PRIMER LUGAR, EL VALOR DE I SE ASIGNA A J. ENTONCES I ES INCREMENTADO.


ES POR ESO QUE J TIENE EL VALOR 10 Y NO 11.

CUANDO EL OPERADOR INCREMENTA O DECREMENTA SIGUE A LA VARIABLE, LA OPERACION


SE EFECTUA DESPUES DE QUE SU VALOR HA SIDO OBTENIDO PARA SER USADO EN LA
EXPRESION.

POR LO TANTO SUPONIENDO QUE MAX TIENE EL VALOR 1.

COUNT = 10 * MAX++;

ASIGNA EL VALOR 10 A COUNT E INCREMENTA EN 1 A MAX.

SI LA VARIABLE ES PRECEDIDA POR EL OPERADOR INCREMETO O DECREMENTO, LA


OPERACION SE EFECTUA PRIMERO Y ACONTINUACION SE OBTINE EL VALOR DE LA
VARIABLE PARA USARLA EN LA EXPRESION.

POR EJEMPLO, REESCRIBIENDO EL PROGRAMA PREVIO COMO SIGUE HACE QUE J SEA
IGUAL A 11.

MAIN()

{
INT I,J;

I = 10;
J = ++I;

// ESTO IMPRIMIRA 11 11

COUT << "I Y J: " << I << " " << J;

RETURN 0;

}
--------------------------------------------------

VARIACIONES DEL BUCLE FOR

---USO MULTIPLE DE VARIABLES DE CONTROL DE BUCLE.---

SE PUEDE USAR MAS DE UNA VARIABLE DE CONTROL DE BUCLE PARA CONTROLAR


UN BUCLE FOR.

FOR (X = 0, Y = 10; X <=Y; X++, Y--)


COUT << X << " " << Y << "/N";

AQUI, X AUMENTA E Y DISMINUYE. TOME NOTA DE LAS COMAS QUE SEPARAN LAS DOS
SENTENCIAS DE INICIALIZACION Y LAS DOS EXPRESIONES DE INCREMENTO.
ESTO ES NECESARIO CON EL FIN DE QUE EL COMPILADOR COMPRENDA QUE HAY DOS
SENTENCIAS DE INICIALIZACION Y DOS DE DECREMENTO E INCREMENTO.

EN C++, LA COMA ES UN OPERADOR QUE ESENCIALMENTE SIGNIFICA


<<HAGA ESTO Y ESTO OTRO>>.

---INDEPENDIZAR LA EXPRESION DE CONDICION.---

LA CONDICION QUE CONTROLA EL BUCLE PUEDE SER CUALQUIER EXPRESION VALIDA


DE C++.
TAMPOCO NECESITA INVOLUCRAR A LA VARIABLE DE CONTROL DE BUCLE.

EJEMPLO

//UN SENCILLO CALCULADOR DE PROPINAS

#INCLUDE <IOSTREM.H>

MAIN()

FLOAT AMOUNT;
CHAR MORE;

FOR (AMOUNT = 1.0; MORE != 'N'; AMOUNT = AMOUNT + 1)


{

COUT << "PARA $" << AMOUNT << " LA PROPINA ES $";
COUT << AMOUNT * 0.15 << " ";
COUT << "MAS? (S/N): ";
CIN >> MORE;
}

RETURN 0;

COMO PUEDE COMPROBAR, LA PORCION DE CONDICION DEL BUCLE NO TIENE


NADA QUE VER CON LA VARIABLE DE CONTROL DE BUCLE.

---PARTES QUE FALTAN.---

OTRO ASPECTO DEL BUCLE FOR ES QUE A DIFERENCIA DE OTROS LENGUAJES EN C++
NO ES NECESARIO QUE ESTEN LAS PARTES DE LA DEFINICON DEL BUCLE.

ESTE PROGRAMA FINALIZA CUANDO SE INTRODUCA EL NUMERO 1000.

#INCLUDE <IOSTREM.H>

MAIN()

{
INT X;

FOR (X = 0; X != 1000;) {
COUT << "INTRODUZCA UN NUMERO : ";
CIN >> X;
}

RETURN 0;

LA PARTE INCREMENTO DE LA DEFINICION DEL FOR ESTA EN BLANCO. ESTO


SIGNIFICA QUE SE REPETIRA EL BUCLE HASTA QUE X SEA IGUAL A 1000.
EL BUCLE NO MODIFICA LA VARIABLE DE CONTROL DEL BUCLE SI NO ESTA
PRESENTE LA PARTE DE INCREMENTO DEL BUCLE.

OTRA VARIACION DEL FOR ES TRASLADAR LA PARTE DE INICIALIZACION DEL BUCLE


HACIA AFUERA DEL BUCLE.

EJEMPLO:

X = 0;
FOR ( ;X < 10; )
{
COUT << X << " ";
++X
}

FIJATE QUE YAMBIEN EL INCREMENTO ESTA EN EL INTERIOR DEL CUERPO.

---EL BUCLE INFINITO.---

PUEDE CREAR UN BUCLE INFINITO.

FOR ( ; ; )
{
//.....
}

---BUCLES SIN OBJETIVOS.---

POR EJEMPLO, EL SIGUIENTE BUCLE SE EJECUTA DESDE 0 A 99.


SIMPLEMENTE ES UN BUCLE DE RETARDO Y NO EFECTUA NINGUNA OTRA ACCION.

FOR ( X= 0; X < 1000; X++);

EL PUNTO Y COMA QUE TERMINA LA LINEA ES NECESARIO PORQUE FOR ESPERA


UNA SENTENCIA, AUNQUE ESTA PUEDA ESTAR VACIA.

--------------------------------------------------
EL BUCLE WHILE

OTRO BUCLE EN C++ ES EL BUCLE WHILE.

WHILE (EXPRESION) SENTENCIA;

EL BUCLE WHILE PUEDE TAMBIEN SER UN BLOQUE DE CODIGO.

EL BUCLE WHILE FUNCIONA REPITIENDO SU OBJETIVO MIENTRAS


LA EXPRESION SEA VERDADERA.

CUANDO SE VUELVE FALSA EL BUCLE SE DETIENE.

EL SIGUIENTE PROGRAMA IMPRIME NUMEROS DEL 1 AL 10.

NUM = 1

WHILE (NUM = <= 10) {

COUT << NUM << " ";


NUM++;

EL VALOR DE LA EXPRESION ES COMPROBADO AL ENTRAR, ESTO SIGNIFICA


QUE SI LA EXPRESION ES FALSA DESDE UN COMIENZO NO SE EJCUTARA NI
UNA SOLA VEZ.

EN ESTE EJEMPLO SI SE INTRODUCE 0, EL CUERPO DE WHILE NUNCA SE


EJECUTARA.

#INCLUDE <IOSTREAM.H>

MAIN()

{
INT NUM;

COUT << "INTRODUZCA UN ENTERO: ";


CIN >> NUM;

//IMPRIMIR LOS NUMEROS IMPARES ENTRE NUM Y 0.

WHILE (NUM) {
IF (NUM%2) COUT << NUM << " ";
NUM--;
}

RETURN 0;

--------------------------------------------------

EL BUCLE DO

EL ULTIMO BUCLE DE C++ ES EL DO.


DO {
SENTENCIAS
}WHILE (EXPRESION);

SI SOLAMENTE SE VA A REPETIR UNA SENTENCIA, LAS LLAVES NO


SON NECESARIAS.

EL BUCLE DO REPITE LA SENTENCIA O SENTENCIAS MIENTRAS LA


EXPRESION SEA VERDADERA. SE DETIENE CUANDO LA EXPRESION ES FALSA.

EL BUCLE DO ES UNICO, SIEMPRE SE EJECUTARA EL CODIGO QUE HAY


DENTRO DEL BUCLE ALMENOS UNA VEZ, PORQUE LA EXPRESION QUE CONTROLA
EL BUCLE SE COMPRUEBA EN LA PARTE INFERIOR DEL BUCLE.

EN EL EJEMPLO SE IMPRIMIRAN LOS NUMEROS DEL 1 AL 10.

X = 1;

DO {

COUT << X << " ";


X++;

} WHILE (X<= 10);

ES IDONEO PARA COMPROBAR ENTRADAS DE MENUS.

--------------------------------------------------

EL BUCLE ANIDADO

CUANDO EL CUERPO DE UN BUCLE CONTIENE OTRO SE DICE QUE EL SEGUNDO ESTA


ANIDADO EN EL PRIMERO.

ESTE PROGRAMA IMPRIME LOS NUMEROS DEL 1 AL 10, DIEZ VECE EN LA PANTALLA.

FOR (I = 0; I < 10; I++) {

FOR (J = 1; J < 11; J++) COUT << J << " ";


COUR << "/N";
}

--------------------------------------------------

USO DE BREAK PARA SALIR DE UN BUCLE

LA SENTENCIA BREAK LE PERMITE SALIR DE UN BUCLE DESDE CUALQUIER PUNTO


SITUADO DENTRO DE SU CUERPO, OMITIENDO LA EXPRESION DE TERMINACION
NORMAL.

LA SENTENCIA BREAK PUEDE UTILIZARSE CON LOS TRES BUCLES.

CUANDO LA SENTENCIA BREAK ES ENCONTRADA DENTRO DE UN BUCLE, ESTA


FINALIZA DE INMEDIATO, Y LA EJECUCION DEL PROGRAMA CONTINUA EN LA
SENTENCIA SIGUIENTE DEL BUCLE.

EN ESTE EJMPLO SOLAMENTE SE IMPRIMEN LOS NUMEROS DEL 1 AL 10.


#INCLUDE <IOSTREAM.H>

MAIN ()

INT I;

FOR (I = 1; I < 100; I++) {


COUT << I << " ";
IF ( I == 10) BREAK; // SALIR DEL BUCLE
}

RETURN 0;

EN LOS BUCLES ANIDADOS UNA SENTENCIA BREAK OCASIONARA UNA SALIDA TAN
SOLO DEL BUCLE MAS INTERNO.

--------------------------------------------------

LA SENTENCIA CONTINUE

LA SENTENCIA CONTINUE EN CIERTO MODO ES O OPUESTO DE LA SENTENCIA BREAK.

OBLIGA A QUE SE EFECTUE LA SIGUIENTE ITERACION DEL BUCLE, SALTANDOSE


CUALQUIER CODIGO RESTANTE.

POR EJEMPLO ESTE PROGRAMA NUNCA MUESTRA NINGUNA SALIDA.

#INCLUDE <IOSTREAM.H>

MAIN ()

{
INT X;

FOR(X = 0; X < 100; X++) {


CONTINUE;
COUT << X << " "; // ESTA NUNCA SE EJECUTARA
}

RETURN 0;

CADA VEZ QUE SE LLEGA A LA SENTENCIA CONTINUE, HACE QUE EL BUCLE


SE REPITA, SALTANDOSE LA SENTENCIA COUT.

EN BUCLES WHILE Y DO-WHILE, UNA SENTENCIA CONTINUE HARA QUE EL CONTROL


SE DIRIGA A LA CONDICION DE PRUEBA Y ENTONCES CONTINUE EL PROCESO DE
BUCLES.

EN EL CASO DE FOR, SE EFECTUARA LA PARTE DE INCREMENTO, SE EJECUTARA


LA PRUEBA DE CONDICION Y EL BUCLE CONTINUARA.
--------------------------------------------------

LA SENTENCIA GOTO

C++ ADMITE LA SENTENCIA DE BIFURCACION LLAMADA GOTO.

LA SENTENCIA GOTO PUEDE EFECTUAR UNA BIFURCACION DENTRO DE UNA FUNCION.

NO PUEDE HACER BIFURCACIONES ENTRE FUNCIONES.

TRABAJA CON UNA ETIQUETA. EN C++ UNA ETIQUETA ES EL IDENTIFICADOR


VALIDO DE UN NOMBRE QUE VA SEGUIDO DE DOS PUNTOS.

EL SIGUIENTE GOTO SE SALTA LA SENTENCIA COUT:

GOTO MYLABEL;

COUT << "ESTO NO SE VA A IMPRIMIR";

MYLABEL: COUT << "ESTO SI SE VA A IMPRIMIR";

EL SIGUIENTE PROGRAMA USA GOTO PARA CREAR EL EQUIVALENTE DE DE UN BUCLE FOR.


QUE SE EJECUTARA DE 1 A 10.

ES TANSOLO UN EJEMPLO EN LA PRACTICA SIEMPRE SE UTILIZA EL FOR.

#INCLUDE <IOSTREAM.H>

MAIN ()

{
INT I;

I = 1;
AGAIN:
COUT << I << " ";
I++;
IF ( I < 10) GOTO AGAIN;

RETURN 0;

--------------------------------------------------

EL AMBITO DE LAS VARIABLES

EL AMBITO DE UNA VARIABLE DETERMINA LAS PARTES DEL PROGRAMA QUE TIENEN ACCESO A
ELLA.

ELAMBITO DE UNA VARIABLE DEPENDE DE DONDE ESTA DECLARADA.

EN C++ HAY TRES LUGARES DONDE SE DECLARAN VARIABLES.

DENTRO DE UN BLOQUE, EN LA DEFINICION DE LOS PARAMETROS DE UNA FUNCION Y FUERA DE


TODAS
LAS FUNCIONES.

VARIABLES LOCALES:
LAS VARIABLES QUE ESTAN DECLARADAS DENTRO DE UN BLOQUE SON VARIABLES LOCALES.

LAS VARIABLES LOCALES NO SON ACCESIBLES POR CODIGO QUE ESTE FUERA DELBLOQUE
EN EL QUE ESTAN DECLARADAS NI EN OTRAS FUNCIONES FUERA DE LA PROPIA.

#INCLUDE <IOSTREAM.H>

VOID FUNC();

MAIN ()

INT X; // LOCAL CON RESPECTO DE MAIN()

X = 10;
FUNC();
COUT << "\N";
COUT << X; // VISUALIZA 10

RETURN 0;

VOID FUNC()

INT X; // LOCAL CON RESPECTO DE FUNC()

X = -199;
COUT << X; // VISUALIZA -199

LA VARIABLE ENTERA X ES DECLARADA DOS VECES, UNA EN MAIN() Y OTRA EN FUNC().

LA X EN MAIN() NO TIENE NINGUN ALCANCE DENTRO NI GUARDA NINGUNA RELACION


CON LA X DE FUNC().

ESPECIFICAMENTE, LOS CAMBIOS QUE SE HACEN EN X DENTRO DE FUNC() NO AFECTARAN


A LA X DENTRO DE MAIN().

POR LO TANTO, ESTE POGRAMA IMPRIMIRA -199 Y 1O EN LA PANTALLA.

EN C++, LAS VARIABLES LOCALES SON CREADAS CUANDO SE ENTRA EN SU BLOQUE Y SON
DESTRUIDAS CUANDO SE SALE DE EL.

LAS VARIABLES LOCALES NO MANTIENEN SUS VALORES ENTRE LLAMADAS DE FUNCION.

#INCLUDE <IOSTREAM.H>

INT SERIES();

MAIN ()
{

INT I;

FOR (I = 0; I < 10; I++) COUT << SERIES() << " ";

RETURN 0;

// ESTO ES INCORRECTO

SERIES()
{
INT TOTAL;

TOTAL = (TOTAL + 1423) % 1422;


RETURN TOTAL;
}

ESTE PROGRAMA INTENTA USAR SERIES() PARA GENERAR UNA SERIE DE NUMEROS EN LA QUE
CADA UNO SE BASA EN EL VALOR DEL PRECEDENTE.

SIN EMBARGO, EL VALOR DE TOTAL NO SERA MANTENIDO ENTRE LLAMADAS A LA FUNCION,


Y LA FUNCION FRACASA EN CUMPLIR CON SU COMETIDO.

AUNQUE TODAS LAS VARIABLES LOCALES ESTAN DEFINIDAS DENTRO DE UNA FUNCION,
EN REALIDAD ESTAN LOCALIZADAS SOLO EN EL BLOQUE EN EL QUE ESTAN DECLARADAS.

POR EJEMPLO, EN EL SIGUIENTE PROGRAMA, DIFERENCIA ES CONOCIDA TAN SOLO DENTRO DEL
BLOQUE.

#INCLUDE <IOSTREAM.H>

MAIN ()

INT MIN,MAX;

FOR (MIN = 0, MAX = 10; MIN < MAX; MIN++, MAX--)


{

INT DIFERENCIA; // DIFERENCIA ES LOCAL RESPECTO DE ESTE BLOQUE

DIFERENCIA = MAX - MIN;


COUT << DIFERENCIA << " ";
}

// COUT << DIFERENCIA << " " ; // ESTA SENTENCIA NO ES VALIDA AQUI
RETURN 0;
}

AQUI DIFERENCIA ESTA DECLARADA DENTRO DEL BLOQUE DE CODIGO ASOCIADO CON EL FOR.
DE ESTA MANERA, ES CONOCIDA EN Y PUEDE SER USADA POR DICHO BLOQUE.

NO OBSTANTE, FUERA DE ESTE BLOQUE, DIFERENCIA NO ES CONOCIDA. PARA DEMOSTRAR


ESTO SUPRIMIMOS LOS COMENTARIOS QUE ENCABEZAN LA ULTIMA SENTENCIA COUT Y
ENTONCES INTENTEMOS COMPILAR EL PROGRAMA. PODREMOS COMPROBAR QUE EL COMPILADOR
NOS DA ERROR.

EN C++, UNA VARIABLE LOCAL PUEDE SER DECLARADA EN CUALQUIER LUGAR DENTRO DE UN
BLOQUE. ESTO SE DIFERENCIA DEL C, QUE REQUIERE QUE LAS VARIABLES LOCALES SEAN
DECLARADAS AL PRINCIPIO DEL BLOQUE.

--------------------------------------------------

VARIABLES LOCALES

LAS VARIABLE GLOBALES MANTIENEN SU VALOR DURANTE TODO EL PROGRAMA.

SE DECLARAN FUERA DE TODA FUNCION.

#INCLUDE <IOSTREAM.H>

VOID FUNC1();
VOID FUNC2();

INT COUNT; // ESTA ES LA VARIABLE GLOBAL

MAIN ()

INT I; // ESTA ES UNA VARIABLE LOCAL

FOR ( I= 0; I < 10; I++)


{
COUNT = I * 2 ; // ACCESO A LA VARIABLE GLOBAL
FUNC1();
}

RETURN 0;

VOID FUNC1()

COUT << "COUNT: " << COUNT; // ACCESO A LA VARIABLE GLOBAL


COUT << '\N';
FUNC1();
}

VOID FUNC2()

INT COUNT; // ESTA ES UNA VARIABLE LOCAL

FOR (COUNT = 0; COUNT < 3; COUNT++) COUT << '.';


}

OBSERVEMOS DE FORMA DETENIDA ESTE PROGRAMA, DEBE QUEDARCLARO QUE AUNQUE NI MAIN()
NI FUNC1() HAN DECLARADO LA VARIABLE COUNT, AMBAS LA PUEDEN USAR.
NO OBSTANTE, EN FUNC2() SE HA DECLARADO UNA VARIABLE LOCAL LLAMADA COUNT.
CUANDO FUNC2() HAGA REFERENCIA A COUNT, ESTARA ACCEDIENDO SOLAMENTE A SU
VARIABLE LOCAL Y NO A LA GLOBAL.

ES IMPORTANTE RECORDAR QUE SI UNA VARIABLE GLOBAL Y UNA VARIABLE LOCAL TIENEN EL
MISMO NOMBRE, TODAS LAS REFERENCIAS A ESE NOMBRE DENTRO DE LA FUNCION EN LA QUE
ESTA DECLARADA LA VARIABLE, SE REFERIRAN A ESA VARIABLE LOCAL Y NO TENDRA NINGUN
EFECTO SOBRE LA VARIABLE GLOBAL.

AUNQEU UN NOMBRE RSTE DECLARADO GLOBALMENTE, SE PUEDE VOLVER A DEFINIR LOCALMENTE


EN UN BLOQUE O FUNCION. DENTRO DL MISMO, EL NOMBRE SE REFIERE A LA VARIABLE LOCAL,
ES
DECIR, LA VARIABLE LOCAL OCULTA A LA GLOBAL. EN C++ ES POSIBLE ACCEDER A LA
VARIABLE
GLOBAL MEDIANTE EL OPERADOR :: DERESOLUCION DE ALCANCE, COMO EN EL SIGUIENTE
EJEMPLO.

#INCLUDE <IOSTREAM.H>

STATIC CHAR C = 'A'; // C GLOBAL DECLARADA FUERA DE MAIN

VOID MAIN ()

CHAR C = 'B'; // C LOCAL AMAIN


{

CHAR C = 'D'; // C LOCALO AL BLOQUE INTERNO


COUT << C; // C ES LA C LOCAL
COUT << ::C; // :C ES LA C GLOBAL

EN ESTE PROGRAMA SE DECLARAN TRES VERSIONES DE LA VARIABLE C


DE TIPO CHAR (CARACTER).

UNA VARIABLE GLOBAL ESTATICA Y DE VALOR 'A'.


UNA VARIABLE LOCAL A LA FUNCION MAIN Y DE VALOR 'B'.
UNA VARIABLE LOCAL AL BLOQUE INTERNO Y DE VALOR 'D'.

LA SEGUNDA LINEA DEL BLOQUE INTERNO HACE REFERENCIA A LA VARIBLE C SIN EL OPERADOR
DE
RESOLUCION DE ALCANCE, POR LO QUE DICHA VARIABLE ES LA C LOCAL DECLARADA DENTRO DEL
BLOQUE INTERNO, Y SU VALOR ES 'D'.

LA TERCERA LINEA DEL BLOQUE INTERNO HACE REFERENCIA A LA VARIABLE C CON EL OPERADOR
DE
RESOLUCION DE ALCANCE, POR LO QUE SE REFIERE A LA C GLOBAL, DECLARADA FUERA DE LA
FUNCION, CUYO VALOR ES 'A'.

POR LO TANTO, EL RESULTADO DE LA EJECUCION DE ESTE PROGRAMA SERA LA APARICION EN LA


PANTALLA DE LA CADENA DE CARACTERES "DA".

SI UN PROGRAMA CONTIENE BLOQUES ANIDADOS, COMO ESTE EJEMPLO, EN UN PUNTO


DETERMINADO
SOLO SE TIENE ACCESO A LA VARIABLE GLOBAL Y LA VARIBLE LOCAL DEL BLOQUE,PERO NO A
LAS
VARIABLES DECLARADAS CON EL MISMO NOMBRE EN BLOQUES INTERMEDIOS. EN EL EJEMPLO
ANTERIOR,
DENTRO DEL BLOQUE INTERNO NO HAY FORMA DE ACCEDER A LA VARIABLE C LOCAL A MAIN,
CUYO
VALOR ES 'B'.

SI UN BLOQUE NO DECLARA UNA VARIABLE LOCAL, PERO SI LO HACE UNO QUE LO CONTIENE, LA
VARIABLE LOCAL DEL BLOQUE EXTERNO SERA ACCESIBLE EN EL INTERNO.

EN EL EJEMPLO ANTERIOR, SI ELIMINAMOS LA DECLARACION.

CHAR C 'D'; // C LOCAL AL BLOQUE INTERNO

LA PRIMERA C DE LA INSTRUCCION SIGUIENTE PASARA A REFERIRSE A LA C LOCAL A MAIN.