Programacion en Lenguaje de Alto Nivel 1

1.
Estructura de un programa en C++
1.1 El formato general de un programa en C++ es el siguiente:
/
| Definición de constantes y macros,
ENCABEZADO < declaración de variables globales,
| Inclusión de archivos.
\
void main(void) <---linea de cabecera de la función principal.

{ <-------------Inicio de bloque.
.........
.........
......... <---Cuerpo de la función principal.
.........
} <-------------Fin de bloque.
En el listado 1.1 se muestra un programa que despliega en la pantalla del monitor

el mensaje:
El Lenguaje C++ es poderoso
// PRIMER.CPP
//
// Despliega un mensaje en la pantalla.
#include <stdio.h> // Para utilizar la función printf()
void main(void)
{
printf("El lenguaje C++ es poderoso\n");
}
Listado 1.1.- Primer programa en C++
1.2.- Archivos de cabecera.
El listado 1.1 contiene la línea :
#include <stdio.h>
En ella, stdio.h es el nombre de un archivo de cabecera en el cual se encuentran declarados los

prototipos de las funciones y macros que se utilizan para la entrada/salida estándar. Existe un
extenso grupo de archivos de cabecera, y cada uno de ellos sirve para manejar un grupo de
funciones relacionadas. La extensión h de estos archivos es la inicial de la palabra header.
Generalmente estos archivos se incluyen en las primeras líneas de los archivos que contienen
el código fuente de los programas en C++ . El compilador de C++ desplegará un mensaje de
error cuando se trate de utilizar una función sin antes haber incluido el archivo de cabecera
que contiene el prototipo de ella.
Docente: Ing. CIP Roberto Carlos Román Anaya 1

Los archivos de cabecera son almacenados en el directorio INCLUDE cuando se instala el
paquete del compilador.
1.3.- Comentarios.
En el C++ existen dos formas de manejar los comentarios:
La primera sirve para escribir comentarios que abarcan varias líneas, y utiliza los caracteres /*
para marcar el inicio de un comentario, y los caracteres */ para marcar el final, como se ve en
los siguientes ejemplos:
/* Este es un pequeño comentario */
/* Este es otro comentario, pero a diferencia del

anterior, utiliza varias líneas.
Observe que también puede incluir líneas en blanco (como la anterior y la

siguiente).
*/
La segunda forma solo sirve para comentarios que abarcan una línea o parte de ella, y utiliza
los caracteres // al principio del comentario. El fin del comentario queda marcado por el fin de
la línea, como se muestra a continuación:
// Este es un comentario de una línea,
// y este es otro.
void main(void) // Este comentario ocupa parte de la línea.

Los comentarios de una sola línea pueden anidarse dentro de los comentarios de varias líneas,
como en :
/* El principio del comentario de varias líneas.
// Primer comentario de una sola línea.
// Segundo comentario de una sola línea.
*/ Fin del comentario de varias líneas.
1.4.- Directivas del preprocesador
El preprocesador es un programa que viene incluido en los compiladores de C++, y se encarga

de ejecutar ciertas órdenes llamadas DIRECTIVAS DEL PREPROCESADOR. Estas directivas
empiezan con el carácter # ( Numeral ).
Al inicio de la compilación, el compilador invoca al preprocesador, quien actúa de acuerdo a la
directiva correspondiente.
Las directivas del preprocesador pueden clasificarse en tres grupos principales:
1.4.1.- Inclusión de archivos
Pueden incluirse los contenidos de otros archivos de texto en el archivo que contiene código
en C++ . Esto se logra por medio de la directiva #include en cualquiera de las tres formas
siguientes :

#include <nombre_archivo>
/* nombre_archivo se buscará solamente en el directorio INCLUDE */
#include "nombre_archivo"
/* nombre_archivo se buscará en el directorio de trabajo actual */
#include "d:\trayectoria\nombre_archivo"
/* En este caso, nombre_archivo será buscado en el directorio especificado en
trayectoria */
Ejemplo:
#include "C:\DATOSCPP\PANTALLA.C"
1.4.2.- Reemplazamiento de cadenas y procesamiento de macros
El reemplazamiento de cadenas consiste en sustituir (antes de efectuar la compilación) cada

una de las ocurrencias de cierta cadena (llamada constante simbólica) por otra cadena
equivalente. Esto de logra por medio de la directiva #define, como se muestra en los siguientes
ejemplos:
#include <stdio.h>
#define CADENA "El Lenguaje C++ es poderoso\n"
void main(void)
{
printf(CADENA);
}
En este caso, el preprocesador sustituirá CADENA por El Lenguaje C++ es poderoso, de tal
manera que el compilador se encontrará con la instrucción: printf("El Lenguaje C++ es
poderoso\n");
#define VALMAX 1000

Aquí, se está definiendo la constante simbólica VALMAX, cuyo valor será el entero 1000.
La directiva #define también sirve para declarar macros, las cuales incluyen una ó más
instrucciones del Lenguaje C++ , como en:
#define CUBO(N) ((N)*(N)*(N))
Esta macro puede utilizarse en una instrucción de la siguiente forma:

r = CUBO(5);
El preprocesador sustituye lo anterior por:

r = ((5)*(5)*(5));
Las macros pueden tomar formas complejas y ocupar varias líneas de código, como se muestra
en el siguiente ejemplo:
#define REDOND(x) ((x)>=0?((x)+1/VALOR1)*(1-1/VALOR1): \

((x)-1/VALOR1)*(1+1/VALOR1))
Obsérvese que al final de la primera línea se escribió una diagonal invertida ( \ ), la cual sirve
como enlace.

1.4.3.- Compilación condicional
Existe un grupo de directivas del preprocesador que permiten controlar cuales partes del
código fuente se van a compilar al cumplirse ciertas condiciones. A continuación se muestra
una lista de tales directivas; dejándose la ejemplificación de su uso para unidades más
avanzadas de este trabajo.
#if
#ifdef
#if defined(algo)
#ifndef
#else
#elif
#endif
Además de las directivas vistas hasta aquí, existen las siguientes:
#error
#pragma inline
#pragma warn
#pragma saveregs
1.5.- La Función main()
Todo programa de C++ debe contener una función llamada main() (principal), la cual sirve de
enlace con el sistema operativo que se esté utilizando. Cuando se intente obtener un
programa ejecutable(.EXE ) a partir de un archivo que no contenga una función main(), el
compilador desplegará un mensaje de error.
Al invocar a un programa escrito en C++, desde el indicador de presencia del sistema

operativo, se le pueden pasar ciertos valores que se llaman argumentos, los cuales van a ser
recibidos por la función principal. Esta, a su vez, va a regresar un valor de retorno al sistema
operativo que la invocó. La devolución del valor de retorno se hace por medio de la instrucción
return, por ejemplo:
return 0 ;
La explicación acerca de la utilización de argumentos en la función main() requiere del
conocimiento de apuntadores, por lo que se tratará en la unidad 6.
1.6.- Identificadores
Los nombres que son utilizados para referenciar variables, funciones, etiquetas y demás
objetos que se manejan con el Lenguaje C++, son referidos en forma genérica como
identificadores.
1.6.1.- Identificadores creados por el usuario
El usuario debe cuidar que los identificadores creados por él cumplan las siguientes:
Reglas generales para los identificadores:

1.- Pueden estar formados por:
a.- Letras mayúsculas y/o minúsculas.

b.- El carácter de subrayado.
c.- Los dígitos del 0 al 9.

2.- El primer carácter debe ser una letra o el carácter de subrayado.
3.- Pueden contener un número arbitrario de caracteres; pero Borland C++

considera como significativos los primeros 32 o los n primeros que
decida el programador, donde:
1 <= n <="32"
4.- Se toma en cuenta la diferencia entre letras mayúsculas y minúsculas,

por lo que : SUMA, Suma y suma son identificadores diferentes.
5.- No puede utilizarse el mismo identificador para dos objetos que se

encuentren dentro del mismo ámbito.
1.6.2.- Palabras reservadas
Las palabras reservadas, como su nombre lo indica, son identificadores que tienen asignado un
uso específico y no podrán ser utilizadas como identificadores creados por el usuario.
La tabla 1.1 muestra las palabras reservadas de Borland C++

_asm @ _ds int @ _seg
+ asm else _interrupt short
auto enum @ interrupt signed
break @ _es @ _loadds sizeof
case @ _export long @ _ss
@ _cdecl extern @ _near static
@ cdecl @ _far @ near struct
char @ far + new switch
+ class @ _fastcall + operator + template
const float @ _pascal + this
continue for @ pascal typedef
@ _cs + friend + private union
default goto + protected unsigned
+ delete _huge + public + virtual
do @ huge register void
double if return volatile
+ inline @ _saveregs while
Tabla 1.1.- Palabras reservadas de Borland C++.
Las palabras marcadas con + en la tabla 1.1 son las palabras reservadas específicas de C++, las
marcadas con @ son las palabras añadidas por Borland al C, y las palabras sin marca son las
palabras reservadas del C estándar.
1.7.- Entrada/Salida
En el Lenguaje C++, la entrada/salida se maneja de dos formas.
La primera consiste en la utilización de las funciones cuyos prototipos vienen declarados en el

archivo stdio.h, y es la forma que tradicionalmente ha utilizado el Lenguaje C.
La segunda es propia del C++ y consiste en el manejo de objetos y operadores cuyas

definiciones se encuentran en el archivo iostream.h .

A continuación explicaremos cada una de estas dos formas.
1.7.1.- Funciones declaradas en stdio.h

En esta forma, se requiere la inclusión de la siguiente línea al principio del programa fuente:
#include <stdio.h>
En el archivo stdio.h se encuentran definidos, entre otros, los prototipos de las funciones
printf(), scanf(), gets() y puts() además de las macros getc(x) y putc(). A continuación
analizaremos cada una de estas funciones y macros:
1.7.1.1.- La función printf()
Esta función es la mas utilizada en C para desplegar información en la pantalla, más no en el

lenguaje C++ como veremos más adelante.
El formato general para la función printf() es:
printf(<cadena_formato> , <elem> , <elem> , ... );
donde:
cadena_formato es una cadena de caracteres encerrada entre comillas

dobles. Esta cadena es enviada a la pantalla ( la
salida estándar ) después de haber sustituidos los
elementos listados después de la cadena.
La sustitución de los elementos se hace de acuerdo a los comandos de formato incluidos en

cadena_formato, los cuales empiezan con un símbolo de porciento ( % ) .
En la tabla 1.2 se muestran los comandos de formato más usuales:
Comando Sirve para:

%d Entero
%u entero sin signo
%ld entero largo
%p valor de apuntador
%f número de punto flotante
%e número de punto flotante en valor exponencial
%c Carácter
%s cadena de caracteres
%x entero en formato hexadecimal
%o entero en formato octal
Tabla 1.2.- Comandos de formato.

A fin de poder mostrar algunos ejemplos de aplicación de la función printf(), se presenta aquí
la tabla 1.3 que contiene los tipos de datos disponibles en el compilador de Borland C++ 3.1.

Tipo Tamaño (bits) Precisión Rango de valores:
char 8 . -128 a 127
unsigned char 8 . 0 a 255
enum 16 . -32,768 a 32,767
int 16 . -32,768 a 32,767
short int 16 . -32,768 a 32,767
unsigned int 16 . 0 a 65,535
long 32 . -2,147'483,648 a 2,147'483,647
unsigned long 32 . 0 a 4,294'967,295
float 32 7 dígitos 3.4E-38 a 3.4E+38
double 64 15 digitos 1.7E-308 a 1.7E+308
long double 80 19 digitos 3.4E-4932 a 3.4E+3932
void . . .
near pointer 16 . Direcciones de memoria
far pointer 16 . Direcciones de memoria
Tabla 1.3.- Tipos de datos, tamaños y rangos en Borland C++ 3.1
1.7.1.2.- La función scanf()
Esta función toma la entrada, normalmente del teclado, y la almacena en variables

previamente
declaradas. El formato para la función scanf() es :
scanf( <cadena_formato> , <elem> , <elem> , ... ) ;
Los significados de <cadena_formato> y <elem> son los mismos que en el caso de la

función printf() . La función scanf() utiliza la mayoría de los comandos mostrados en la
tabla 1.2 La función scanf() debe utilizarse con cautela cuando se van a introducir
valores numéricos y de cadenas de caracteres en una sola instrucción.
1.7.1.3.- Las funciones gets() y puts()
Las funciones scanf() y printf() sirven para varios formatos, por lo cual son muy
voluminosas. Es por esto que se han desarrollado las funciones gets() y puts(),
específicas para la entrada/salida de cadenas de caracteres.
La función gets() toma una cadena de caracteres desde el teclado y la almacena en la

variable cuyo identificador aparece como argumento en la invocación a gets(), como en:
gets(nombre);

La función puts() despliega en la pantalla una cadena de caracteres que se encuentra
almacenada en la variable cuyo identificador aparece como argumento en la invocación a la
función puts().
1.7.1.4.- Las macros getc() y putc()
La macro getc(c) toma un caracter desde el teclado y lo almacena en la variable c.

Por su parte, putc() despliega un caracter en la pantalla. Estas macros están definidas en
el archivo stdio.h .
1.7.2.- Funciones declaradas en conio.h.
La consola es un concepto heredado de los ambientes multiusuario, y está formada por

el teclado y el monitor. En las implementaciones de Borland C++ existe una serie de
funciones que manejan la entrada/salida por la consola, entre otras:
clrscr(), que limpia la pantalla y posiciona el cursor en la esquina superior izquierda

de la ventana actual.
gotoxy(a,b), posiciona el cursor en la posición establecida por la columna a y el

renglón b.
window(a,b,x,y), establece la ventana actual. Los valores a,b pertenecen a la columna

y el renglón de la esquina superior izquierda; los valores x,y corresponden a la
columna y el renglón de la esquina inferior derecha de la nueva ventana.
getch(), toma un carácter desde el teclado y no lo despliega en la pantalla.
getche(), toma un carácter desde el teclado y lo despliega en la pantalla.

Para poder utilizar las funciones relacionadas con la consola, es necesario incluir la linea:
#include <conio.h>
Donde conio.h es el archivo de cabecera donde se encuentran declarados los prototipos

de las funciones que manejan la entrada/salida estándar por la consola.
Los listados 1.2 a 1.8 muestran ejemplos de utilización de formatos por medio de algunas
funciones antes mencionadas
// IMPRIME ENTEROS EN "DECIMAL"
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("%13d\n",y);
getch();
return 0;
}
Listado 1.2

// IMPRIME ENTEROS EN OCTAL
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("y = %13d EN DECIMAL\n",y);
printf("y = %13o EN OCTAL\n",y);
getch();
return 0;
}
Listado 1.3
// IMPRIME ENTEROS EN HEXADECIMAL
#include<stdio.h>
#include<conio.h>
int main()
{
int y=12345;
printf("y = %13d EN DECIMAL\n",y);
printf("y = %13x EN HEXADECIMAL\n",y);
getch();
return 0;
}
Listado 1.4
// IMPRIME ENTEROS SIN SIGNO
#include<stdio.h>
#include<conio.h>
int main()
{
int y= -12345;
printf("y = %13d ENTERO CON SIGNO\n",y);
printf("y = %13u ENTERO SIN SIGNO\n",y);
getch();
return 0;
}
Listado 1.5
// IMPRIME NUMEROS CON PUNTO FLOTANTE

#include <stdio.h>
#include<conio.h>
int main()
{
float x=123.45;
double y=678.90;
printf("x = %12.2f\ny = %12.1f\n",x,y);
getch();
return 0;
}
Listado 1.6

// IMPRIME CARACTERES
#include <stdio.h>
#include<conio.h>
int main()
{
char a='X', b='Y', c='Z' ;
printf("%c%c%c\n",a,b,c);
getch();
return 0;
}
Listado 1.7
// IMPRIME CADENAS DE CARACTERES

#include <stdio.h>
#include<conio.h>
int main()
{
/*
Formato: %[-a.b]s
donde: - JUSTIFICA A LA IZQUIERDA

a NUMERO DE ESPACIOS DISPONIBLES PARA DESPLEGAR
b NUMERO MAXIMO DE CARACTERES QUE PUEDEN DESPLEGARSE
*/
printf("\n%10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");

printf("\n%-10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%-25.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
printf("\n%.10s","DESPLEGADO DE CADENAS EN LENGUAJE C++");
getch();
return 0;
}
Listado 1.8
Para desplegar el símbolo de porciento puede escribirse en

cadena_formato : % . Por ejemplo:
..........
..........
int utilidad;
utilidad = 30;
printf("La utilidad es del %2d %\n", utilidad);
..........
desplegará :
La utilidad es del 30 %

1.7.3.- Objetos declarados en iostream.h
C++ provee una nueva forma para manejar la entrada/salida, proporcionando una
sintaxis más sencilla, elegante e intuitiva que la de stdio.h , además de un mecanismo
más eficiente y flexible. La palabra iostream tiene su origen en las palabras: input
output stream , por lo que puede traducirse como flujo de entrada/salida. El flujo de
entrada/salida es utilizado para enviar datos desde una fuente ( productor ) a un destino (
consumidor ) . En esta forma se tiene una vasta jerarquía de clases para el manejo de
entrada/salida para archivos y dispositivos. En el archivo iostream.h se encuentran
definidos los objetos cin y cout.
El objeto cin utiliza al operador sobrecargado >> para tomar datos desde la entrada
estándar (habitualmente el teclado). El objeto cout utiliza al operador sobrecargado <<
para enviar datos hacia la salida estándar (normalmente la pantalla). Veamos como se
utilizan estos elementos en un pequeño ejemplo:
#include <iostream.h>
int main()
{
char nombre[30];
cout << "CUAL ES TU NOMBRE ? " ; cin>> nombre ;
cout << "\n" ; cout << "!! HOLA , " << nombre << " !! \n" ;
system("PAUSE");
return 0 ;
}
Listado 1.9.- Ejemplo de utilización de cin y cout
También es posible especificar el ancho de un campo por medio del manipulador setw(),
que se encuentra declarado en iomanip.h ; así como los manipuladores window(),
clrscr() y gotoxy() declarados en constrea.h, como se muestra en el listado 1.10.
#include <iomanip.h>
#include <constrea.h>
int main()
{
char nombre[10] ;
int numero = 150 ;
float sueldo ;
constream ventana0, ventana1, ventana2 ;
ventana0.window(1,1,80,25);
ventana0.clrscr();
ventana1.clrscr();
cout << "NUMERO: " << setw(3) << numero;
cout << " NOMBRE : " ; cin.getline(nombre,10);
ventana2.clrscr();
cout << "\nSUELDO : $ " ; cin>> sueldo ;
return 0;
} // verificar http://faculty.salisbury.edu/~dxdefino/constrea.htm
Listado 1.10.- Uso de manipuladores.

2.- Constantes, variables, operadores
En esta unidad se trata el manejo de los objetos donde se almacenan los datos, así como
las operaciones que pueden realizarse con los valores almacenados.
En este contexto, llamaremos objeto a una región identificable de memoria que puede
almacenar un valor fijo o variable. No debe confundirse el significado que se dá aquí al
vocablo objeto con el que tiene en la Programación Orientada a Objetos.
2.1.- Constantes
Podemos definir a una constante como una localidad de memoria (objeto), la cual tiene
un nombre y un tipo de dato asociados, además de un valor que permanece fijo durante
el tiempo de ejecución.
En la unidad 1 se estudió la manera de definir constantes por medio de la directiva

#define . Aquí definiremos a las constantes utilizando el modificador const, usando del
formato mostrado a continuación:
const <tipo> <identificador> = <valor>
Ejemplo: const int iva = 10 ;
Los valores para las constantes, permitidos por Borland C++, se clasifican en cuatro
clases:
I).- Enteros, que pueden escribirse en formato:
I.a).- Decimal, con valores de 0 a 4,294'967,295.
Ejemplo: const int smin = 15300 ;
I.b).- Octal, que deben empezar con un 0 (cero).
Ejemplo: const int lim = 030 ; (decimal 27)
I.b).- Hexadecimal, que empiezan con 0X ó 0x (cero x)
Ejemplo: const int mem = 0xFFFF ;
II).- Caracteres, compuestos de uno o más caracteres encerrados entre comillas

sencillas (apóstrofes).
Ejemplo: const char inicial = 'A' ;
Para manejar los caracteres de control se utilizan las secuencias de escape que
empiezan con el carácter de diagonal hacia atrás (\) seguida de un carácter. Si el
carácter que sigue a la diagonal es alguno de los caracteres mostrados en la tabla 2.1,
se obtendrá el efecto explicado en ella; pero si es cualquiera de los demás caracteres
del Código ASCII, se visualizará el carácter tal cual.

Secuencia Caracter Efecto
\a BEL Sonido de la bocina
\b BS Retroceso
\f FF Alimentación de forma
\n LF Nueva línea
\r CR Retorno de carro
\t HT Tabulación horizontal
\v VT Tabulación vertical
\\ \ Diagonal hacia atrás
\' ' Comilla sencilla
\" " Comilla doble
\? ? Interrogación
\O O Cualquiera O=Número octal de hasta tres dígitos
\x H Cualquiera H=Número hexadecimal
Tabla 2.1.- Secuencias de escape.
Borland C++ permite el uso de dos caracteres juntos como valores de caracteres.
Por ejemplo: 'AB' , '\n\t' , '\007\007'
III).- Punto flotante, cualquiera con punto decimal ó con formato exponencial.
Ejemplos: 3.135 , 0. , .0 , 34e3 , -3.4 , .075E12
IV).- Enumeración, son identificadores definidos en declaraciones de tipo enum.
Ejemplo: enum frutas { pera, uva, manzana, fresa } ;
donde: pera, uva, manzana y fresa son constantes de enumeración y tienen los
siguientes valores:
pera = 0
uva = 1
manzana = 2
fresa = 3
Pueden asignarse valores explícitos como en:
enum frutas {pera, uva , manzana = 10 , fresa = uva+5} ;
y entonces :
pera = 0
uva = 1
manzana = 10
fresa = 6

2.2.- Variables
Una variable es un espacio de memoria que tiene un nombre y un tipo de dato

asociados, además de un valor que puede cambiarse durante el tiempo de ejecución.
En el Lenguaje C++ puede declararse una variable en cualquier lugar del programa, con
la única restricción de que la declaración preceda a la primera instrucción donde se
utiliza tal variable.
El formato para la declaración de una variable o grupo de variables es el siguiente:
[, var2, ... ] ;
Ejemplos:
int algo, otro ;
int suma = 0 , inicial = 1 ;
float desc , acum = 0 ;
char prim = 'A' , seg ;
2.3.- Ambito
El ámbito es una zona de programa donde puede utilizarse un identificador para accesar
su objeto . El ámbito va a depender, básicamente, del lugar del programa en que aparece
la declaración.
Bajo este enfoque, se tienen las siguientes clases de ámbito:
Ambito de BLOQUE.
En el Lenguaje C++, se generaliza el concepto de ámbito local, a través de la

introducción del concepto de bloque.
Un bloque está formado por las instrucciones delimitadas por un par de llaves { }.
Es posible anidar una serie de bloques, y pueden declararse variables dentro de cada
bloque. Si, en diferentes bloques, existen variables con el mismo identificador, todas
serán consideradas como variables diferentes. Así que puede tenerse:
..............
..............
int x=5; // x del bloque 1
{
{
{
printf("x=%d",x); // x=30
}
printf("%d",x); // x=20
}
printf("%d",x); // x=10

}
printf("%d",x); // x=5
.............
.............
Debe tenerse cuidado al utilizar identificadores iguales para diferentes variables. Lo más
recomendable es no utilizar los mismos identificadores y no intentar manejar variables
en un ámbito diferente al que pertenecen.
Ambito de FUNCION.
En esta clase sólo se encuentran los identificadores que se utilizan como etiquetas
cuando se tienen instrucciones goto. El identificador de una etiqueta debe ser único
dentro de una función, y no puede utilizarse la instrucción goto para saltar de una
función a otra.
Ambito de PROTOTIPO DE FUNCION.
El ámbito de los identificadores utilizados dentro de los paréntesis en la declaración de

prototipo de una función, finaliza con la declaración del prototipo.
Ambito de ARCHIVO.
Las variables declaradas fuera de cualquier bloque en un archivo son consideradas como
variables globales, y el ámbito de sus identificadores abarca todos los bloques
contenidos en el archivo en cuestión; por lo que: una variable con éste ámbito puede ser
utilizada en las funciones del archivo que estén definidas después del punto donde se
declaró dicha variable.
2.4.- Duración
La duración define el periodo de tiempo durante el cual los identificadores declarados

tienen objetos asignados en memoria. Las variables, por ejemplo, tienen memoria
asignada durante el tiempo de ejecución.
Existen tres clases de duración:
2.4.1.- Duración estática
Los objetos con duración estática están localizados en memoria durante todo el tiempo
de ejecución del programa. Las funciones, las variables con ámbito de archivo y las
variables con especificadores de clase de almacenamiento static ó extern, tienen
duración estática. Los objetos con duración estática son inicializados a cero , en
ausencia de un valor inicial explícito.
2.4.2.- Duración local
Los objetos de duración local, conocidos también como objetos automáticos, son
creados en la pila de la memoria RAM ó en los registros del microprocesador. La
memoria asignada a éstos objetos es liberada cuando finaliza la ejecución del bloque

donde fueron creados. Los objetos de duración local deben utilizarse siempre en un
ámbito local ó de función. Cuando se utiliza el especificador de clase de
almacenamiento register, se implica el uso del especificador de clase de
almacenamiento auto.
2.4.3.- Duración dinámica
Los objetos de duración dinámica se crean y se destruyen, por invocaciones a funciones

específicas, durante el tiempo de ejecución de un programa. El almacenamiento de estos
objetos se dá en el área de reserva de la memoria RAM llamado montículo.
2.5.- Enlace
En la creación de un programa ejecutable, primero se lleva a cabo la compilación de

diversas unidades de traslación, las cuales se componen del código fuente junto con los
archivos incluidos. Posteriormente, el archivo objeto (.obj) , se enlaza con librerías
preexistentes para obtener el archivo ejecutable (.exe).
El enlace es el proceso que permite a cada instancia de un identificador asociarse

correctamente con un objeto o función particular. Todos los identificadores tienen uno
de los siguientes atributos de enlace, íntimamente relacionados con su ámbito:
. ENLACE EXTERNO,
. ENLACE INTERNO,
. SIN ENLACE.
Estos atributos se determinan a través del emplazamiento y los formatos de las

declaraciones, junto con el uso (implícito ó explícito) de los especificadores de clase de
almacenamiento static ó extern. Cada instancia de un identificador con enlace externo
representa al mismo objeto ó función a través de todo el conjunto de archivos y librerías
que componen el programa.
Cada instancia de un identificador con enlace interno representa al mismo objeto ó

función solamente dentro de un archivo. Los identificadores sin enlace representan
entidades únicas.
A continuación se presentan las:
REGLAS PARA LOS ENLACES INTERNO Y EXTERNO:
1. Cualquier identificador de objeto ó archivo que tenga ámbito de archivo tendrá

enlace interno si su declaración contiene el especificador static.
Para C++, si el mismo identificador aparece con ambos tipos de enlace en el
mismo archivo, el identificador tendrá enlace externo.

2. Si la declaración de un identificador de un objeto ó función contiene el
especificador extern, el identificador tendrá el enlace correspondiente a una
declaración con ámbito de archivo.
3. Si una función se declara sin un especificador de clase de almacenamiento, su

enlace está determinado como si se hubiera utilizado el especificador extern.
4. Si un identificador de objeto con ámbito de archivo se declara sin especificador

de clase de almacenamiento, el identificador tendrá enlace externo.
Los siguientes identificadores no tienen atributo de enlace:
a).- Cualquier identificador declarado para ser algo diferente de un objeto ó

función ( p.ej. un identificador typedef ).
b).- Los parámetros de las funciones.
c).- Los identificadores de ámbito de bloque para objetos declarados sin el el

especificador extern.
Para aclarar lo relacionado con el especificador extern, revisemos los listados 2.1 y 2.2.
// EXTERN1.CPP
int edad; char nombre[31]; // DEFINICION de variables globales
Listado 2.1.- EXTERN1.CPP, que define las variables globales.
// EXTERN2.CPP
// DECLARACION de variables globales que:
extern int edad; // se encuentran en otro archivo
extern char nombre[];
void main()
{
cout << "\nCUAL ES TU NOMBRE ? " ; cin>> nombre ;
cout << "\nCUANTOS AÑOS TIENES, " << nombre << " ?" ; cin>> edad ;
cout << "\n\n" ;
cout << " TE FALTAN " << 100-edad ;
cout << " PARA LLEGAR A LOS CIEN, " << nombre << "\n" ;
}
Listado 2.1.- EXTERN2.CPP, que declara y utiliza variables globales definidas en otro
archivo.
En el archivo EXTERN1.CPP se definen las variables globales edad y nombre.

Posteriormente se compila este archivo para obtener el archivo EXTERN1.OBJ.
En el archivo EXTERN2.CPP se declaran las variable edad y nombre utilizando el

modificador extern.

Finalmente, se crea un proyecto al que puede llamarse EXTERN.PRJ, en el cual se
incluyen los archivos EXTERN1.OBJ y EXTERN2.CPP; se compila el proyecto y se
obtiene el archivo ejecutable EXTERN.EXE
2.6.- Operadores
Los objetos que se manejan en C++ van a tener un tipo de dato asociado, el cual
determina la cantidad de espacio de almacenamiento que se le asigna a cada uno de los
objetos de tal tipo, así como el conjunto de operaciones que podrán realizarse con los
valores almacenados. Las operaciones serán representadas a través de identificadores
específicos llamados operadores.
En esta sección estudiaremos los operadores, agrupándolos en:
2.6.1.- Operadores ariméticos
Los operadores aritméticos se aplican sobre objetos con valores numéricos, como se
muestra en la tabla 2.2 .
Sean: X = 20 , Y = 30 , A = 100.0 , B = 200.0
Operador Operación Ejemplo Resultado

+ Adición Z=X+Y Z=50
- Sustracción Z=Y-X Z=10
* Multiplicación Z=X*Y Z=600
/ División Z=Y/X Z=1.5
% Módulo Z=Y%X Z=10
++ Incremento X++ X=21
-- Decremento X- X=19
Tabla 2.2.- Operadores aritméticos.
2.6.2.- Operadores relacionales
Los operadores relacionales se usan para comparar los valores que resultan de reducir
expresiones. Los resultados coincidirán con los valores de verdad:
FALSO igual a CERO, VERDADERO diferente de CERO. Los operadores relacionales

en C++ son :
> Mayor que
>= Mayor ó igual que

< Menor que
<= Menor ó igual que
== Igual que
!= Diferente que ( No igual que )

2.6.3.- Operadores lógicos
Los operadores lógicos se aplican sobre los enunciados que resultan de las operaciones
relacionales, y el resultado siempre será un valor de verdad. Los operadores lógicos son:
&& Y ( Conjunción )
|| O ( Disyunción )
! NO ( Negación )
2.6.4.- Operadores entre bits
Con estos operadores se puede realizar la comprobación, colocación ó desplazamiento

de los bits actuales de una variable de los tipos int y char.
Los operadores entre bits son:
& Y ( Conjunción )
| O ( Disyunción )
^ O ( Disyunción Exclusiva ó XOR )
~ ( Complemento a uno ó NOT )
>> ( Desplazamiento a la DERECHA )
<< ( Desplazamiento a la IZQUIERDA )
A continuación se presentan ejemplos de algunas operaciones entre bits:
Ejemplo 2.6.1:
Supongamos que se quiere cambiar el bit de paridad ( el de la extrema izquierda ) de

uno a cero. Para esto puede utilizarse la operación de conjunción entre bits.
Si tenemos la declaración:
char indice = 81 ;
y, suponiendo que se quiere cambiar el bit de paridad de 1 a 0 , la instrucción en C++ se

escribiría :
indice & 127 ;
La operación realizada a mano es :
11010001 <------ indice

operador> &
01111111 <------ 127 en binario
01010001 <------ resultado

En este caso se utilizó el número 127 porque es el único número entero que puede
escribirse en un octeto ( byte ) y que tiene los siete primeros bits con valor 1 .
Ejemplo 2.6.2
Se requiere que en el número 112 tengan valor 1 los bits que correspondan con los del
número 7 que tengan valor 1. En este caso, la operación a utilizar es la disyunción entre
bits, quedando las instrucciones en la siguiente forma:
char masc ;
masc = 112 | 7 ;
La operación manual tomaría la siguiente forma:
01110000 <------ 112 en binario
operador> |
00000111 <------ 7 en binario
01110111 <------ resultado
Ejemplo 2.6.3
La disyunción exclusiva sirve para poner a uno los bits del primer operando cuyos
correspondientes bits en el segundo operando sean distintos, como se ve a continuación:
x = 125 ^ 120 ;
char x ;
Manualmente se tendría:
01111101 <------- 125 en binario

operador> ^
01111000 <------- 120 en binario
00000101 <------- resultado
Los operadores de desplazamiento mueven todos los bits, de una variable entera ó de
carácter, hacia la izquierda ó hacia la derecha. A medida que los bits son desplazados
hacia un extremo, los lugares desocupados del estremo contrario van siendo ocupados
por ceros. Los unos que salen por los extremos no se pueden recuperar(no hay rotación).
2.6.5.- Operadores de asignación
El estudio de los operadores de asignación requiere del conocimiento de los conceptos

de valor izquierdo ( lvalue ) y de valor derecho ( rvalue ). Un valor izquierdo es una
expresión que designa un objeto. Las expresiones utilizadas como valor izquierdo
corresponden a objetos cuyos valores pueden cambiar durante la ejecución de un
programa. Generalmente, en la expresión correspondiente a un valor izquierdo aparece
el identificador de una variable. Cuando el valor izquierdo se refiere a la dirección de
una variable, la expresión puede constar de una combinación de varios identificadores.

Un valor derecho es una expresión formada por cualquier combinación de objetos y
operadores que pueda ser reducida a un valor. Los operadores de asignación sirven para
asignar un valor derecho a un valor izquierdo, y están formados por la combinación del
operador de asignación simple = con otro operador, como se muestra en la tabla 2.3 .
Operador Significado Ejemplo: Equivale a:

= Asignación múltiple .
+= Suma asigna X+=Y X=X+Y
-= Resta asigna X-=Y X=X-Y
*= Multiplicación asigna X*=Y X=X*Y
/= Divide asigna X/=Y X=X/Y
%= Residuo asigna X%=Y X=X%Y
<<= Dezplaz. izq. asigna X<<Y X=X<<Y
>>= Dezplaz. der. asigna X>>Y X=X>>Y
&= Conj. e/bits asigna X&=Y X=X&Y
^= Disy. exclu. asigna X^=Y X=X^Y
|= Disyunción asigna X|=Y X=X|Y
Tabla 2.3.- Operadores de asignación.
Los operadores estudiados hasta aquí no son todos los que existen en el C++, sino los
que a mi juicio son indispensables para iniciar el estudio del lenguaje. Si,
posteriormente, es necesario utilizar algún operador no tratado en esta unidad, en ese
momento se estudiarán las características particulares de tal operador.
3.- Instrucciones de control

En esta unidad estudiaremos las instrucciones que sirven para controlar el flujo de
ejecución de un programa en C++ . De acuerdo a las características de cada una, las
clasificaremos en grupos de estructuras básicas de:
Las estructuras básicas deben cumplir con la condición básica de la Programación

Estructurada de: sólo una entrada, sólo una salida.
3.1.- Secuencia
A este grupo pertenecen las instrucciones que están formadas por una o varias
expresiones simples colocadas una a continuación de la otra. La sintaxis para las
instrucciones estructuradas en secuencia es la siguiente:
instruccion_1 ;
instruccion_2 ;
.........
instruccion_N ;

Su diagrama de flujo se presenta en la figura 3.1.
Ejercicios
1. Elabore un programa que permita determinar la distancia (m) que recorre un móvil
que se desplaza con una velocidad (m/s) constante, después de transcurrir un
determinado tiempo (s)
#include <stdio.h>
#include <conio.h>
int main()
{
int V;
int T;
int D;
printf("\n INGRESE ");
printf("\n ");
printf("\n Velocidad (m/s) : "); scanf("%i",&V);;
printf("\n Tiempo (s) : "); scanf("%i",&T);;
D= V*T;
printf("\n RESULTADO ");

printf("\n ");
printf("\n Distancia recorrida en metros es: %2.i ", D);
getch();
return 0;
}
2. Dado dos números diferentes, determinar y mostrar la suma, resta y multiplicación de
estos numeros.
3. Elabore programa que permita determinar la velocidad final (m/s) de un auto que realiza
un MRUV, conociendo la velocidad inicial (m/s), el tiempo que transcurre (s) y la
aceleración (m/s²)
Datos de prueba: Vi = 40 m/s; T = 12 s A = 5 m/s²
Vf = Vi + A*T

Vf: velocidad final Vi: velocidad inicial
A: aceleración T: tiempo
4. Elabore un programa que permita determinar el promedio que ha obtenido un alumno en
un determinado curso, conociendo las notas de: tres prácticas, el examen parcial y el
examen final.
Datos de prueba: P1 = 15; P2 = 17; P3 = 16; EP = 14; EF = 15
PP = ( P1 + P2 +P3 ) / 3
PROM = ( PP + 2*EP + 3*EF ) / 6
PP: promedio de práctica PROM: promedio
EP: examen parcial EF: examen final
5. Elabore un programa que permita determinar el trabajo (joule) que realiza un motor,
conociendo la potencia (watt o vatios) que realiza en un determinado tiempo (segundo).
Datos de prueba: potencia = 300 w ; tiempo = 5 s
6. Elabore un programa que permita determinar el área (cm²) de un triángulo, conociendo su
base (cm) y su altura (cm).
Datos de prueba: base = 6 cm; altura = 8 cm
7. Elabore un algoritmo/programa que permita determinar la hipotenusa (cm) de un
triángulo rectángulo, conociendo sus catetos (cm)
Datos de prueba: cateto1 = 4 cm; cateto2 = 3 cm
8. Elabore un algoritmo/programa que permita convertir la velocidad de un auto que esta en
km/h a m/s
Dato de prueba: velocidad = 9 km/h
9. Elabore un algoritmo/programa que permita determinar el área (cm²) de un triángulo
equilátero, conociendo su lado (cm).
Dato de prueba: lado = 8 cm
10. Elabore un algoritmo/programa que permita determinar el área (cm²) de un circulo,
conociendo su radio (cm).
Dato de prueba: radio = 2 cm; π = 3.1415
11. Elabore un programa que acepte los siguientes datos de un trabajador: código, nombre,
horas normales de trabajo, pago por hora normal, horas extras (el pago por hora extra es
el 50% más del pago por hora normal), seguidamente se debe mostrar: importe por horas
normales, importe por horas extras y el importe total.
3.2.-Selección
A este grupo pertenecen aquellas instrucciones que sirven para que la ejecución del
programa tome una de varias opciones existentes en una ramificación.
En C++ se tienen las siguientes instruccións de selección:
3.2.1.- La instrucción if - else
Esta instrucción permite elegir entre dos opciones de ejecución, y su sintaxis es :
if( condición )
[bloque_1]
[else]
[bloque_2]
donde:
bloque_1 y bloque_2 pueden estar formados por uno ó
más instrucciones.

else es opcional, y en caso de no existir, bloque_2
tampoco existirá.
Al ejecutarse esta estructura, primero se evalúa la condición. En caso de que, de esta

evaluación, resulte un valor de verdad verdadero, se ejecutarán las instrucciones que
forman el bloque_1; en caso contrario (si el valor de verdad es falso), se ejecutarán las
instrucciones del bloque_2.
El diagrama de flujo para la estructura if-else se presenta en la figura 3.2.
Esta estructura puede anidarse para elgir entre un grupo de más de dos opciones,
tomando la siguiente forma:
if(condición_1)
bloque_1;
else if(condición_2)
bloque_2;
else if(condición_3)
bloque_3;
............
else
bloque_N;
A continuación se muestran algunos ejemplos de aplicación de la instrucción if-else
int main()
{
long ncontrol;
cout << "NUMERO DE CONTROL: "; cin>> ncontrol;

if(ncontrol<=0)
cout << "NUMERO INVALIDO.........";
else cout << "CORRECTO !!" << "\n\n\n";
system("PAUSE");
return 0;
}

Listado 3.1.- Uso de if-else
#include <conio.h>
int main()
{
int calif;
clrscr();
cout << "CALIFICACION: "; cin>> calif;
if(calif > 100)
cout << "ERROR: CALIFICACION DEMASIADO ALTA .....";
else if(calif < 0)
cout << "ERROR: CALIFICACION DEMASIADO BAJA .....";
else if( (calif>= 70) && (calif <=100))
cout << "CALIFICACION APROBATORIA.";
else cout << "CALIFICACION REPROBATORIA.";
getch();
return 0;
}
Listado 3.2.- Uso de if-else-if
Ejercicios (uso de if)
1. Elabore un programa que permita determinar la velocidad (m/s) constante de un móvil

que se ha desplazado una determinada distancia (m), en un cierto tiempo (s). Se debe
considerar que el valor del tiempo debe ser mayor de cero
Datos de prueba: Distancia = 146m; Tiempo = 5s
#include <stdio.h>
#include <conio.h>
int main()
{
float V;
int T;
int D;
printf("\n ");
printf("\n Distancia (m) : "); scanf("%i",&D);
printf("\n Tiempo (s) : "); scanf("%i",&T);
if (T > 0)
V= static_cast<float>(D) / static_cast<float>(T);
printf("\n RESULTADO ");
printf("\n ");
printf("\n La velocidad en m/s es: %5.2f ", V);
getch();
return 0;
}
2. Elabore un programa que permita determinar el tiempo (s) que transcurrirá hasta que dos
autos se encuentren, considerando que estos autos separados una distancia (m) van uno
al encuentro del otro con velocidad constante (m/s)
Datos de prueba: distancia = 130 m
auto1: velocidad = 5 m/s T= D / (V1 + V2)

Espacio = Distancia
auto2: velocidad = 8 m/s
3. Elabore un programa que permita determinar el tiempo (s) que transcurrirá hasta que un
auto alcanza al otro, se sabe que estos autos separados una distancia (m) van en igual
dirección con velocidad constante (m/s). Considere la velocidad del primero auto mayor.
Datos de prueba: distancia = 120 m
auto1: velocidad = 9 m/s T= D / (V1 - V2)
auto2: velocidad = 6 m/s
4. Elabore un programa que permita determinar la aceleración (m/s²) de un bloque que se
encuentra en reposo, conociendo su masa (kg) y la fuerza (Newton) horizontal que se le
Espacio = Distancia
aplica. Se debe considerar que el valor de la masa sea mayor de cero
Datos de prueba: Fuerza = 54 N; Masa = 6 kg
5. Elabore un programa que permita determinar la potencia (watt o vatios) que realiza un
motor, conociendo el trabajo (joule) que realiza en un determinado tiempo (segundo). El
valor del tiempo debe ser positivo y diferente de cero
Datos de prueba: trabajo = 1000 j ; tiempo = 5 s
6. Elabore un programa que permita determinar si un número ingresado es un número
entero.
Dato de prueba: número = 57
7. Elabore un programa que permita determinar si un número entero positivo es número par.
Dato de prueba: numero = 38
8. Elabore un programa que permita expresar una cantidad dada en segundos a horas,
minutos y segundos. La cantidad debe ser entera y mayor a cero
Dato de prueba: Cantidad = 8000 s
Ejercicios (uso de if – else / if – else - if)
1. Elabore un programa que permita determinar la velocidad (m/s) constante de un móvil

que se ha desplazado una determinada distancia (m), en un cierto tiempo (s). Se debe
considerar que los valores ingresados sean positivos y mayores de cero
Datos de prueba: Distancia = 146 m; Tiempo = 5 s
#include <stdlib.h>
int main()
{
int D;
int T;
float V;
cout<<"\n INGRESE ";
cout<<"\n ";
cout<<"\n Distancia (m) : ";cin>>D;
cout<<"\n Tiempo (s) : ";cin>>T;
if (T > 0 & D > 0)
{
V= static_cast<float>(D) / static_cast<float>(T);
cout<<"\n RESULTADO ";
cout<<"\n ";
cout<<"\n La Velocidad en m/s es : "<<V;
cout<<"\n ";
}
else
cout<<"\n Ingrese valores positivos y mayores a cero";
system("PAUSE");

return 0;
}
2. Elabore un programa que permita aceptar dos números diferentes, seguidamente se debe
determinar y mostrar el mayor de los números.
3. Elabore un programa que permita aceptar un número entero de dos cifras, de tal manera
que si sus cifras son pares se debe mostrar la suma de estas cifras, pero si las cifras son
impares se debe mostrar el producto de estas cifras.
4. Elabore un programa que permita aceptar un número entero, seguidamente se debe
determinar y mostrar si el número es múltiplo de siete.
5. Elabore un programa que permita aceptar un número entero menor a 31524,
seguidamente se debe determinar y mostrar cuantas cifras tiene dicho número.
6. Elabore un programa que permita aceptar un número entero de dos cifras, seguidamente
se debe mostrar el número ingresado pero con sus cifras intercambiadas. Ej. Si el número
ingresado es 38 se debe mostrar 83.
7. Elabore un programa que permita aceptar los siguientes datos de un trabajador: código,
nombre, sueldo básico, año de ingreso a la empresa y número de hijos.
Si los años de servicio es mayor a 8 años se le da una bonificación de 10 soles por cada
año, en caso contrario se le da 4 soles por cada año de servicio. Si el numero de hijos es
menor a 4 se le da 8 soles por cada hijo, en caso contrario se le da sólo 20 soles. El sueldo
bruto es la suma del sueldo básico, la bonificación por años de servicio y la bonificación
por los hijos. Si el sueldo bruto es mayor a 1500 soles se le hace un descuento del 1.5% del
sueldo bruto, en caso contrario el descuento es el 0.5% del sueldo bruto. El sueldo neto es
igual al sueldo bruto menos el descuento.
Se pide realizar los cálculos necesarios para mostrar las bonificaciones, el sueldo bruto, el
descuento y el sueldo neto.
8. Elabore un programa que permita aceptar un número entero, seguidamente se debe
determinar y mostrar si el número ingresado es positivo, cero o negativo.
9. Elabore un programa que permita aceptar tres números diferentes, seguidamente se debe
determinar y mostrar el mayor y menor de los números.
10. Elabore un algoritmo/programa que permita determinar las raíces reales de una ecuación
de segundo grado (Ax² + Bx + C).
Dato de prueba: x² + 5x + 6
Para determinar las raíces puede utilizar
 B  B2  4AC  B  B2  4AC
2A 2A

3.2.2.- La instrucción switch
Esta instrucción es útil cuando se tiene que elegir entre más de dos opciones, como es el
caso de manejo de menús. Esta instrucción es preferible que el uso de anidamientos de
varios if-else.
Su sintaxis es:
switch(expresión_entera)
{
case Const_1 : Bloque_1 ; break ;
case Const_2 : Bloque_2 ; break ;
.............................
.............................
.............................
case Const_N : Bloque_N ; break ;
default : Bloque_X ;
}
A la entrada en una instrucción switch, primero se evalúa la expresión_entera. En caso

de que el resultado coincida con Const_1, se ejecuta el Bloque_1 y break interrumpe la
ejecución del instrucción; en caso de que coincida con el valor de Const_2, se ejecuta el
Bloque_2 , se interrumpe la ejecución de la instrucción. Lo mismo pasa en caso de que
el resultado coincida con cualquiera de los otros valores constantes. En caso de existir
default:, y si el resultado no coincide con ninguno de los valores constantes, se ejecutan
las instrucciones contenidas en el Bloque_X.
Esta estructura puede representarse con el diagrama mostrado en la figura 3.3.
Es recomendable el uso de la instrucción switch en el caso del manejo de un menú de

opciones como se observa en el listado 3.3.

#include <conio.h>
void main()
{
char opcion;
clrscr();
gotoxy(30,5);
cout << "MENU DE OPCIONES"; gotoxy(30,8);
cout << "1.- CREACION"; gotoxy(30,10);
cout << "2.- MODIFICACION"; gotoxy(30,12);
cout << "3.- ELIMINACION"; gotoxy(30,14);
cout << "0.- SALIDA"; gotoxy(30,18);
cout << "SU OPCION ? "; opcion= getche();
cout << "\n\n";
switch(opcion)
{
case '1': clrscr(); cout << "RUTINA DE CREACION \n"; break;
case '2': clrscr(); cout << "RUTINA DE MODIFICACION \n"; break;
case '3': clrscr(); cout << "RUTINA DE ELIMINACION \n"; break;
case '0': clrscr(); cout << "SALIDA DE LA APLICACIÓN \n";break;
default: clrscr(); cout << "OPCION INVALIDA.....\n";
}
}
Listado 3.3.- Uso de switch
Ejercicios
1. Elabore un algoritmo/programa que acepte un número entero y positivo desde 1 hasta 7 y

permita determinar que día de la semana le corresponde
Dato de prueba: Número = 3
#include<stdio.h>
#include<conio.h>
int main()
{
int N;
printf("\n ");
printf("\n Numero desde 1 hasta 7 : ");scanf("%i",&N);
switch (N)
{
case 1:
printf("\n Lunes ");
break;
case 2:
printf("\n Martes ");
break;
case 3:

printf("\n Miercoles ");
break;
case 4:
printf("\n Jueves ");
break;
case 5:
printf("\n Viernes ");
break;
case 6:
printf("\n Sabado ");
break;
case 7:
printf("\n Domingo ");
break;
default:
printf("\n No existe el dia ");
}
getch();
return 0;
}
2. Elabore un programa que acepte un número entero desde 1 hasta 12 (representa un mes
del año) y permita determinar a que estación del año pertenecen
3. Elabore un programa que permita ingresar dos números enteros y un operador aritmético
(+, -, /, *), seguidamente se debe determinar el resultado de la operación que indica el
operador.
Datos de prueba: A = 10 ; B = 5 ; OP = *
A: es el primer número; B: es el segundo número; OP: es el operador
4. Elabore un programa que permita aceptar el sueldo básico de un trabajador así como su
categoría (A, B, C). Se pide determinar cuanto se le debe pagar si se sabe que si la
categoría es “A” se le descuenta el 3% de su sueldo básico; si es “B” se le bonifica con el
1% de su sueldo básico y si es “C” se le bonifica con el 2% de su sueldo básico.
Datos de prueba: SB = 1000 soles; CAT = B
5. Elabore un programa que acepte un número entero hasta tres cifras, seguidamente se
debe determinar cuales de sus cifras tienen raíz cuadrada exacta
3.3.- Iteración
Las estructuras de iteración se utilizan en la ejecución repetida de un bloque de

instrucciones. En el Lenguaje C++, se tienen: Para el manejo de las estructuras de
iteración.
3.3.1.- La instrucción while
Con esta instrucción se maneja una estructura en la que, de entrada, se evalúa una
condición. En caso de que el resultado de tal evaluación sea un valor diferente de cero ,
se ejecuta un bloque de instrucciones, en el cual debe existir una instrucción que

modifique la condición, ya que de lo contrario ejecutará un ciclo infinito ( loop ). Si el
resultado de la evaluación es un valor igual a cero, el bloque de instrucciones no se
ejecuta y finaliza la ejecución de la instrucción.
La sintaxis de la instrucción while es la siguiente:
while(condición)
bloque;
En la figura 3.4 se presenta el diagrama de la instrucción while.
El listado 3.4 muestra el uso de la instrucción while.
#define FALSO 0
int main()
{
int valor=1;
system("cls");
while(valor!=FALSO)
{
cout<<"\n Teclee un valor entero ( 0 para salir ): "; cin>>valor;
}
return 0;
}
Listado 3.4.- Uso de la instrucción while
Ejercicios
1. Elabore un programa que permita sumar todos los números naturales menores a un
número ingresado.
#include<stdio.h>
#include<conio.h>

int main()
{
int N;
int I, S;
printf("\n ");
printf("\n Numero limite para la suma: "); scanf("%i",&N);
I = 1;
S = 0;
while ( I < N)
{
S = S + I; // hacemos uso de un acumulador
I = I +1;
}
printf("\n La Suma es: %i",S);
printf("\n ");
getch();
return 0;
}
2. Elabore un programa que permita sumar todos los números naturales menores a un
número ingresado. Los números sumados deben ser pares
3. Elabore un algoritmo/programa que permita contar todos los números naturales menores
a un número ingresado. Los números contados deben ser pares
4. Elabore un algoritmo/programa que permita contar todos los números naturales que se
encuentran en un rango de números (incluyendo estos numeros). Los números contados
deben ser pares
Dato de prueba: Rango de Números = 13 a 45, es decir debe ingresar dos números (13 y
45).
5. Elabore un programa que permita multiplicar y sumar todos los números naturales
menores a un número ingresado. Los números considerados deben ser multipos de tres.
6. Elabore un programa que permita sumar y multiplicar todas las cifras de un numero
entero ingresados
7. Elabore un programa que permita sumar todas las cifras impares de un numero entero
ingresados
8. Elabore un programa que permita sumar todas las cifras de posición impar y todas las
cifras de posición par (por separado), seguidamente se debe mostrar la diferencia de estos
resultados
9. Elabore un algoritmo/programa que permita aceptar un número entero en el sistema
decimal y expresarlo en el sistema de numeración, cuya base debe ser ingresada y mayor a
uno pero menor a diez

3.3.2.- La instrucción do - while
La instrucción do-while tiene un comportamiento similar a while, sólo que en este caso
primero se ejecuta el bloque de instrucciones y después se evalúa la condición. Con esto
se asegura que el bloque se ejecutará al menos una vez.
Esta es la sintaxis de la instrucción do-while :
do
bloque;
while(condición);
La instrucción do-while puede representarse con el diagrama mostrado en la figura 3.5.
Como una aplicación de la instrucción do-while , se presenta en el listado 3.5 una

variante al problema resuelto en el listado 3.3 .
#include <conio.h>
void main()
{
char opcion;
do
{ // inicia ciclo 1
clrscr();
gotoxy(30,5);
cout << "MENU DE OPCIONES";
gotoxy(30,8); cout << "1.- CREACION";
gotoxy(30,10); cout << "2.- MODIFICACION";
gotoxy(30,12); cout << "3.- ELIMINACION";
gotoxy(30,14); cout << "0.- SALIDA";
gotoxy(30,18); cout << "SU OPCION ? ";
window(42,18,42,18);
do
{ // inicia ciclo 2 clrscr();
opcion="getche();"
}while((opcion < '0')||(opcion>'3'));// fin ciclo 2

window(1,1,80,25);
switch(opcion)
{
case '1': clrscr();
cout << "RUTINA DE CREACION\n";
break;
case '2': clrscr(); cout << "RUTINA DE MODIFICACION\n";
break;
case '3': clrscr(); cout << "RUTINA DE ELIMINACION\n";
break;
case '0': clrscr(); cout << "SALIDA DE LA APLICACIÓN \n";
break;
}
cout << "\n\nPULSE CUALQUIER TECLA PARA CONTINUAR.."; getch();
}while(opcion!="0" ); // fin ciclo 1 }
Listado 3.5.- Aplicación de la instrucción do-while
Ejercicios
1. Elabore un programa que permita sumar todos los números naturales hasta un número
ingresado.
int main()
{
int N;
int I, S;
cout<<"\n ";
cout<<"\n Numero limite para la suma : ";cin>>N;
S = 0;
I = 1;
do
{
S = S + I;
I = I + 1;
}
while ( I <= N);
cout<<"\n La Suma es: "<<S;
cout<<"\n ";
system("PAUSE");
return 0;
}
2. Elabore un algoritmo/programa que permita elegir que desea determinar el usuario con
respecto a la formula V=D/T
V : Velocidad D : Distancia T: Tiempo
int main()
{
float V, D, T;
int OP;
int Resp;
do
{
cout<<"\n Que desea determinar en V = D / T ";

cout<<"\n 1. Velocidad ";
cout<<"\n 2. Distancia ";
cout<<"\n 3. Tiempo ";
cout<<"\n Opcion "; cin>>OP;
switch (OP)
{
case 1:
cout<<"\n Ingrese ";
cout<<"\n Distancia (m) "; cin>>D;
cout<<"\n Tiempo (s) < > de cero "; cin>>T;
V = D / T;
cout<<"\n La velocidad en (m/s) es: "<<V;
break;
case 2:
cout<<"\n Velocidad (m/s) "; cin>>V;
cout<<"\n Tiempo en segundos "; cin>>T;
D = V* T;
cout<<"\n La distancia en metros es: "<<D;
break;
case 3:
cout<<"\n Velocidad (m/s) < > de cero ";cin>>V;
cout<<"\n Distancia en metros "; cin>>D;
T = D / V;
cout<<"\n El Tiempo en segundos es: "<<T;
break;
default:
cout<<"\n Opcion Incorrecto ";
}
cout<<"\n Desea Continuar SI = 9 / NO = 0? ";cin>>Resp;
} while ( Resp == 9);
cout<<"\n ";
system("PAUSE");
return 0;
}
3. Elabore un programa que permita sumar y contar todos los números naturales hasta un
número ingresado. Los números considerados deben ser múltiplos de cinco
Dato de prueba: Número ingresado = 80
4. Elabore un programa que permita determinar, utilizando un menú de opciones, el área de
un cuadrado, un triangulo, un círculo y un trapecio.
5. Elabore un algoritmo/programa que permita elegir que desea determinar el usuario con
respecto a la formula T= D / (V1 - V2)
6. Elaborar un programa que acepte un número entero, seguidamente se debe determinar el
factorial de la mayor cifra (valor absoluto) que tiene el número ingresado.
7. Elaborar un programa que acepte un número entero, seguidamente se debe determinar si
el numero ingresado es numero perfecto
8. Elaborar un programa que determine y muestre todos los números perfecto menores a
100.

3.3.3.- La instrucción for
Entre las instrucciones de iteración, for es la más versátil, ya que, entre otras
características, permite la declaración de variables dentro de su estructura.
La sintaxis de la instrucción for es la siguiente:
for(inicialización ; condición ; control)

bloque;
donde:
inicialización es un bloque de instrucciones que puede
incluir la declaración de las variables
involucradas y la asignación de valores
iniciales.
condición es una instrucción que puede evaluarse de

tal forma que se obtenga como resultado un
valor de verdad ( falso ó verdadero ).
Mientras, se cumpla la condición, se ejecu-
tará el bloque de instrucciones.
control es un bloque de instrucciones separadas por

comas y que controlan la variación de los
valores de las variables utilizadas.
Los bloques de inicialización, condición y control no son obligatorios, pero sí lo son los
tres punto y coma que los separan; de tal suerte que la forma mínima de una instrucción
for quedaría así:
for(;;) // ciclo infinito

; // no realiza tarea alguna
El diagrama para la instrucción for se muestra en la figura 3.6.

El listado 3.6 muestra el uso de la instrucción for.
#include <conio.h>
int main()
{
clrscr();
for(int x=1 ; x <= 25 ; x++)
{ for(int y=1 ; y <=80 ; y++)
{ gotoxy(y,x);
if((x==25) && (y==80))
getch();
cout << '.';
}
}
return 0;
}
Listado 3.6.- Utilización de la instrucción for
Ejercicios
1. Elabore un algoritmo/programa que permita sumar todos los números naturales hasta un
número ingresado.
int main()
{
int N;
int I, S;
cout<<"\n ";
S = 0;
for ( I = 1; I <= N; I++)

cout<<"\n ";
system("PAUSE");
return 0;
}
2. Elabore un algoritmo/programa que permita sumar todos los números naturales hasta un
número ingresado. Los números sumados deben ser pares
3. Elabore un algoritmo/programa que permita contar todos los números naturales que se
encuentran en un rango de números, incluyendo el rango. Los números contados deben
ser múltiplos de cinco.
Dato de prueba: Rango de Números = 13 a 45, es decir debe ingresar dos números (13 y
45)
4. Elabore un algoritmo/programa que permita aceptar un número entero mayor a la unidad
y determinar si es primo absoluto o no.
5. Elabore un algoritmo/programa que permita generar la serie de Fibonacci, con una
cantidad de términos igual a un número entero ingresado
BREAK Y CONTINUE
Los enunciados break y continue son utilizados para modificar el flujo de control dentro de un
programa.
El break utilizado dentro de las estructuras de controlcausa la inmediata salida de dicha
estructura (por lo tanto no sigue repitiéndose el bloque y continúa la ejecución de las
instrucciones que le siguen a la estructura de control).
Veamos un ejemplo del uso de break:
int main()
{
int num;
num = 1;
while (num <= 10)
{
if (num == 5)
{
break;
}
cout<<num <<"; ";

num = num + 1;
}
cout<<"\n ";
system("PAUSE");
return 0;
}
El código anterior imprime:
1–2–3–4–
Lo que sucede es que cuando la variable num toma el valor 5, la condición del while se

cumple, al ingresar al bloque se evalúa en la estructura if si num es igual a 5 y se ejecuta el
break saliendo del bloque while. Num termina valiendo 5 pues jamás se ejecuta la suma num
= num + 1.
Por otra parte, el enunciado continue, dentro de las estructuras de repetición, al ser ejecutado
salta las instrucciones que siguen en el bloque y ejecuta la siguiente repetición en el ciclo.
Veamos un ejemplo para aclarar el funcionamiento de continue:
int main()
{
int num;
num = 0;
while (num <= 7)
{
num = num + 1;
if (num == 5)
{
continue;
}
cout<<num<<"; ";
}
cout<<"\n ";
system("PAUSE");
return 0;
}
1 – 2 – 3 – 4 – 6 – 7- 8
Como vemos, en una de las repeticiones se saltea la impresión del número 5.
Algunos programadores dicen que el uso del break y del continue dentro de las
estructuras de control (excepto el break en la estructura switch) viola las normas de la
programación estructurada. Lo cierto es que no es necesario el uso de break y continue
si se utilizan las estructuras correctas
4.- Diseño de funciones

Las funciones son el módulo básico para la construcción de programas en C++.
Además de la función main(), con frecuencia es necesario utilizar funciones adicionales

que pueden ser accesadas a través del enlace de librerías precompiladas ó a través de su
definición en el archivo de código fuente ó en archivos de cabecera.
En esta unidad estudiaremos los procedimientos necesarios para el manejo de las

funciones definidas en el código fuente.

En principio, debemos distinguir entre: declarar, definir e invocar una función, ya que la
confusión de éstos términos es causa de frecuentes problemas.
Desde los orígenes del Lenguaje C ha existido la distinción entre definir y declarar una
función. Cuando se define una función se le está reservando espacio de almacenamiento
en memoria; en cambio cuando se declara solo se está avisando que más adelante se
encuentra una función con ciertas características, pero no se le reserva espacio en
memoria.
4.1.- Definición de funciones
La definición de una función implica reservarle espacio de almacenamiento en

memoria, de acuerdo al tipo de dato a retornar.
Es en la definición donde se incluye el cuerpo de la función.
El formato general de la definición de una función es el siguiente:
tipo identificador( argumentos )

{
bloque;
}
donde:
tipo es el tipo de dato que va a retornar la función, e identificador es el nombre de la

función.
La existencia de argumentos dependerá de la tarea que va a realizar la función, pero el

par de paréntesis es requisito indispensable.
En el ejemplo 4.1. se presenta una aplicación de la definición, la declaración y la

invocacion de funciones.
4.2.- Declaración de funciones
Cuando se declara una función, se está avisando al compilador que más adelante
encontrará la definicion de tal función, y que por el momento, tome nota de las
características de ella, como son: el tipo de dato que retorna, su nombre y los tipos de
argumentos que va a recibir. Con esto, no habrá ningún problema en invocar a la
función en un bloque de programa ubicado antes del lugar donde se encuentra escrita su
definición.
En el ejemplo 4.1, las líneas:
void saludo();
float calcula(float);
representan la declaración de las funciones ó la declaración de los prototipos de las

funciones saludo() y calcula().

En la declaración de la función saludo() se especifica que no va a retornar valor alguno,
y que no recibirá argumentos.
En la declaración de la función calcula() se especifica que va a retornar un valor de tipo

float, y que va recibir un argumento de tipo float.
Es importante observar que la declaración de una función es parecida a la línea de

encabezado de su definición , sólo que en el caso de la declaración se escribe un punto y
coma al final.
También cabe hacer notar que en la declaración no se requiere escribir identificadores

para los argumentos, como se observa en el ejemplo 4.1, sino que basta con incluir los
tipos de datos de los argumentos. Se pueden incluir identificadores de argumentos, sólo
que el ámbito de tales identificadores estará restringido a la declaración de la función
correspondiente.
Por lo tanto, la declaración:
float calcula(float); podría haberse escrito así :
float calcula(float arg);
En este caso, el identificador arg no tiene uso alguno; por lo que es innecesaria su
inclusión.
Si el número de argumentos, o los tipos correspondientes no coinciden entre la

declaración y la línea de encabezado de la definición de la función el compilador
marcará un error.
4.3.- Invocación a funciones
Una invocación ó llamada a una función implica pasarle el control de la ejecución del
programa, así como los argumentos ó parámetros que requiere para realizar su tarea. En
el listado 4.1 se tienen las líneas:
saludo(); //INVOCACION A LA FUNCION saludo()

precio = calcula(costo); //INVOCACION A LA FUNCION calcula()
En la primera, se invoca a la función saludo() y no se le pasa ningún argumento. En la

segunda, se invoca a la función calcula(), pasándosele como argumento una copia del
valor que tiene la variable costo. El valor retornado por calcula() se asigna a la variable
precio.
// ENCABEZADOS
// DECLARACION DE FUNCIONES
void saludo();
float calcula(float);
// DEFINICION DE LA FUNCION PRINCIPAL
int main()
{
float costo, precio;
system("CLS");

cout << "\n COSTO : $ "; cin>> costo;
cout << "\n PRECIO : $ " << precio;
cout << "\n ";
system("PAUSE");
return 0;
}
// DEFINICION DE LA FUNCION saludo()
void saludo()
{
system("CLS");
cout << "\n !! BIENVENIDO A LA VENTA ESPECIAL !!";
}
// DEFINICION DE LA FUNCION calcula()
float calcula(float x)
{
return( x * 1.6);
}
Listado 4.1.- Diseño de funciones usando prototipo.
4.4.- El prototipo de una función ¿es obligatorio?
Cuando encuentra la primera invocación a una función, el compilador verifica si ya se

realizó la declaración ó la definición de la función invocada. En caso de no existir ni
declaración ni definición previa, enviará un mensaje de error diciendo que la función
invocada debe tener un prototipo. En ese momento se detiene la compilación y no se
genera el archivo .OBJ correspondiente.
Lo anterior puede sugerir que el prototipo de la función invocada es indispensable. La

realidad es que se puede omitir el prototipo si escribimos la definición de la función
antes de su primera invocación, como se muestra en el ejemplo 4.2.
// ENCABEZADOS
// DEFINICION DE LA FUNCION saludo()
void saludo()
{
system("CLS");
cout << "\n !! BIENVENIDO A LA VENTA ESPECIAL !!";
}
// DEFINICION DE LA FUNCION calcula()
float calcula(float x)
{
return( x * 1.6);
}
// DEFINICION DE LA FUNCION PRINCIPAL
int main()
{ float costo, precio;
system("CLS");
cout << "\n COSTO : $ "; cin>> costo;
cout << "\n PRECIO : $ " << precio;
cout << "\n ";
system("PAUSE");
return 0;

}
Listado 4.2.- Diseño de funciones sin uso de prototipos.
Aunque el prototipo no es obligatorio, es recomendable utilizarlo, ya que de esta manera

se permite al compilador verificar que el número y tipos de argumentos utilizados en la
invocación (parámetros actuales) coinciden con los de la definición (parámetros
formales).
La declaración de prototipos también sirve para que el usuario de un programa conozca

la forma de utilización de la función, sin tener que proporcionarle el código fuente.
Por ejemplo, si tenemos un programa que maneja operaciones matemáticas podemos
distribuir a los usuarios el código objeto que contenga las definiciones de las funciones
y un archivo de cabecera que contenga los prototipos.
4.5.- Sobrecarga de funciones
En la mayoría de los casos, los identificadores ó nombres de los objetos deben ser
únicos, esto es, que dos objetos dentro del mismo ámbito no deben tener el mismo
nombre. Una de las excepciones la constituyen las funciones, que pueden compartir el
mismo nombre entre varias de ellas, dando la impresión de que a una sola función se le
ha "sobrecargado de tareas", razón por la cual se les llama funciones sobrecargadas.
Por ejemplo, supongamos que deseamos una función que sirva para sumar números. Lo
ideal sería contar con una sola función que realizara la suma de números de diferentes
tipos y que retornara un valor de acuerdo al tipo de resultado. El Lenguaje C++ permite
resolver este problema por medio de la sobrecarga de funciones.
A continuación se muestran los prototipos para cada una de las funciones que
comparten el nombre suma :
int suma(int,int); // Recibe enteros, devuelve entero
float suma(float,float);
double suma(double,double);
Aquí surge la pregunta: ¿ cómo distingue el compilador entre cada una de las funciones
suma()?.
Debido a que varias funciones sobrecargadas pueden usar el mismo identificador, C++
utiliza el concepto de nombres ampliados para controlar cada función individualmente.
El nombre ampliado de una función se construye tomando como base el nombre de la
función y los tipos de los argumentos. El tipo de retorno de la función no se utiliza en la
formación del nombre ampliado. La composición del nombre ampliado ocurre a nivel
del compilador, no al nivel del enlazador. El enlazador resuelve fácilmente las
referencias externas para sobrecargar las funciones debido a que éstas tienen nombres
ampliados únicos.
Ejercicios

1. Elabore un programa que permita utilizar una función que determine la suma de dos
números enteros.
Dato de prueba: Primer numero = 12; Segundo numero = 10
//función que permite sumar dos números enteros
int suma(int a, int b)
{
int s;
s = a + b;
return s;
}
// fin de la función
int main()
{
int A, B;
int S;
cout<<"\n ";
cout<<"\n Primer numero : ";cin>>A;
cout<<"\n Segundo numero : ";cin>>B;
S= suma(A, B); //Se invoca a la funcion
cout<<"\n ";
cout<<"\n La suma es : "<<S;
cout<<"\n ";
system("PAUSE");
return 0;
}
2. Elabore un programa que permita utilizar una función que determine la suma, resta,
multiplicación y división de dos números enteros (no utilizar una función para cada
operación).
Dato de prueba: Primer numero = 12 Segundo numero = 10
3. Elabore un programa que permita utilizar una función que determine el área de: un
triángulo (b*h/2), un cuadrado (l*l) y un circulo (3.1415*r*r), Utilizar una función para
cada área a determinar.
Dato de prueba: base = 4; altura = 6; lado = 5; radio = 3
4. Elabore un programa que permita utilizar una función para determinar el máximo común
divisor de dos números enteros.
Primera forma
int mcd(int a , int b)
{
int r; //usaremos el r como residuo
a = (a < 0) ? -a:a; //le damos el intervalo a
b = (b < 0) ? -b:b; //le damos el intervalo b
r = (a < b) ? a:b; //le damos el intervalo desde a hasta b
while ( (a % r) || (b % r)) //Usamos el "o"

--r; //Decremento "--"
return r;
}
int main()
{
int A, B;
float D;
cout<<"\n ";
D= mcd(A, B); //Se invoca a la funcion
cout<<"\n ";
cout<<"\n El maximo comun divisor (MCD) es: "<<D;
cout<<"\n ";
system("PAUSE");
return 0;
}
Segunda forma
int mcd(int a , int b)
{
int r; //usaremos el r como residuo
do
{
r=a%b;
a=b;
b=r;
}while (b!=0);
return a;
}
int main()
{
int A, B, X;
float D;
cout<<"\n ";
if (A<B)
{
X=A;
A=B;
B=X;
}
D= mcd(A, B); //Se invoca a la funcion
cout<<"\n ";

cout<<"\n El maximo comun divisor (MCD) es: "<<D;
cout<<"\n ";
system("PAUSE");
return 0;
}
5. Elabore un programa que permita utilizar una sola función para determinar la suma, resta
y multiplicación de dos números enteros.
5.- Arreglos.
Los arreglos consisten de un conjunto de elementos del mismo tipo almacenados en
localidades contíguas de memoria. Los elementos de un arreglo comparten el mismo
nombre, pudiéndo distinguirse un elemento de otro a través de un subíndice.
En esta unidad, describiremos la declaración de los arreglos, el manejo de los elementos

de un arreglo dado, así como lo relacionado con los arreglos que se utilizan para formar
las cadenas de caracteres.
5.1.- Declaración de arreglos
Los elementos de los arreglos son variables de algún tipo dado, que al compartir el
mismo nombre pueden ser tratadas como una sola entidad.
La sintaxis para la declaración de un arreglo es la siguiente:
tipo identificador [ <expresión_constante> ] ;
donde:
tipo es el tipo de los elementos que componen el arreglo
identificador es el nombre del arreglo
expresión_constante es una expresión que al reducirse debe

dar como resultado un valor
entero positivo.
En el ejemplo 5.1 se muestra la declaración de arreglos.

DECLARACION RESULTADO
char nombre[31]; Declara un arreglo unidimensional llamado

nombre compuesto de 31 elementos de tipo
carácter.
int valor[20]; Declara un arreglo unidimensional llamado
valor, compuesto por 20 elementos de tipo
entero con signo.
unsigned long abc[x] Declara un arreglo unidimensional llamado
abc, compuesto por x elementos de tipo
entero largo sin signo. En este caso x
debe ser una constante entera.
double matriz[5][7]; Declara un arreglo bidimensional llamado
matriz, compuesto por 35 elementos de
tipo entero.
int trid[3][5][8]; Declara un arreglo tridimensional llamado
trid, compuesto por 120 elementos de tipo
entero.
Ejemplo 5.1.- Declaraciones de arreglos.

Como se observa en el ejemplo 5.1, la declaración de un arreglo multidimensional se
distingue en que se agrega una pareja de corchetes para cada dimensión, por lo que la
sintaxis, en este caso, toma la siguiente forma:
tipo identificador [ cte1 ][ cte2 ][ cte3 ] ... ;
donde: cte1, cte2, etc. representan los subíndices para cada

dimensión.
El número y tamaño de las dimensiones solo estará restringido por la disponibilidad de

memoria RAM, por lo que se puede tener una declaración como la siguiente:
double multidim [5][5][5][5][5][5] ;
El espacio de memoria ocupado por el arreglo multidim es el mismo que el ocupado

por:
double unidim [15625]
5.2.- Manejo de arreglos
En la sección anterior se ha tratado lo relacionado con la declaración de arreglos con

elementos de diferentes tipos y con una o varias dimensiones. En esta sección se tratará
lo relativo al acceso a los elementos individuales de un arreglo, ya sea para asignarles
valores específicos o para utilizar los valores almacenados.
5.2.1.- Asignación de valores a los elementos de un arreglo
Al declarar un arreglo dentro de una función, los valores almacenados en cada uno de
los elementos son desconocidos (se dice que el arreglo "tiene basura"), lo cual causa que
el programa correspondiente arroje resultados inesperados. Para evitar los valores
desconocidos, se recomienda asignar valores iniciales a cada uno de los elementos de
los arreglos, como se muestra a continuación:
Por ejemplo, supongamos la siguiente declaración:

int vector[5];
En este caso, se declara un arreglo de 5 variables de tipo entero agrupadas con el

nombre vector, las cuales pueden representarse con la figura 5.1.
Figura 5.1.- Representación de un arreglo

Como puede observarse en la figura 5.1, el primer subíndice tiene valor cero y el último
tiene valor cuatro.
Lo anterior se debe a que, en C++, el primer subíndice siempre vale cero y el último
tiene un valor menor en uno que el valor de la dimensión del arreglo.
Una vez declarado el arreglo, se pueden asignar valores a cada uno de sus elementos,
como se muestra enseguida:
vector[0] = 100 ;
vector[1] = 101 ;
vector[2] = 102 ;
vector[3] = 103 ;
vector[4] = 104 ;
y el arreglo vector luciría como en la figura 5.2.
Figura 5.2.- El arreglo vector después de asignarle valores.
En este caso particular, pudimos haber asignado los valores por medio de un estatuto for
de la siguiente forma:
for( int x = 0 ; x < 5 ; x++)

vector[x] = x + 100 ;
Esta forma es la más conveniente en caso de que la cantidad de elementos sea grande y
que los valores a asignar sean iguales o las diferencia entre elementos consecutivos sea
constante.
Todo lo escrito en este ejemplo es válido para arreglos con elementos de cualquier tipo.

Por ejemplo, si queremos desplegar en pantalla los caracteres del código ASCII lo
haríamos por medio del siguiente grupo de instrucciones:
unsigned char caracter[256];

for( int x=0 ; x < 256 ; x++ )
printf("%c", caracter[x]) ;
Ejercicios
1. Elabore un programa que permita aceptar 10 números enteros y seguidamente se deben

mostrar estos números ingresados.
Dato de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
int main()
{
int NUM[10];
int I;
cout<<"\n INGRESE 10 NUMEROS ENTEROS ";
cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n LOS NUMEROS INGRESADOS SON: ";
cout<<"\n ";
for ( I=1; I<=10;I++)
cout<<NUM[I]<<" ";
cout<<"\n ";
system("PAUSE");
return 0;
}
mostrar estos números ingresados ordenados en forma ascendente.
Datos de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
int main()
{
int NUM[10];
int I, J, AUX;

cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n ";
// haciendo uso del metodo de la burbuja
for ( I=1; I<=9;I++)
for ( J=I + 1; J<=10;J++)
if (NUM[J] < NUM[I])
{
AUX = NUM[I];
NUM[I]= NUM[J];
NUM[J]= AUX;
}
cout<<"\n numeros ordenados en forma ascendente ";

cout<<"\n ";

for ( I=1; I<=10;I++)
cout<<NUM[I]<< " ";
cout<<"\n ";
system("PAUSE");
return 0;
}
3. Elabore un algoritmo/programa que permita aceptar 10 números enteros y seguidamente

se deben mostrar la suma de estos de números y su promedio.
Dato de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
se deben mostrar el número menor y el número mayor.
Datos de prueba: 34, 56, 32, 54, 67, 21, 89, 47, 91, 13
se deben mostrar la suma de de las cifras del mayor de los números ingresados.
Dato de prueba: 342, 356, 632, 154, 687, 221, 189, 647, 891, 913
6. Elabore un algoritmo/programa que permita aceptar 10 números enteros, seguidamente
se deben mostrar la división del mayor entre el menor de los números ingresados.(PUEDE
INGRESARSE EL NUMERO CERO UNA O VARIAS VECES . SI SE DA ESTE CASO LA DIVISION
DEBE SER CON EL SIGUIENTE MENOR NUMERO DIFERENTE DE CERO.)
Dato de prueba: 2, 0, 6, 154, 0, 21, 18, 7, 81, 13
se deben mostrar la cantidad de valores que son mayores al promedio de todos los
numeros.
Dato de prueba: 342, 356, 632, 154, 687, 221, 189, 647, 891, 913
se debe crear dos arreglos más, el primero debe contener todos los números que se han
ingresado pero que son primos absolutos y en el segundo arreglo el resto de los números
ingresados. Se debe mostrar el contenido de estos dos arreglos
Dato de prueba: 31, 43, 63, 54, 87, 21, 19, 47, 91, 13
Arreglo con dos dimensiones.
Cuando se manejan arreglos de varias dimensiones, debe recordarse que el subíndice de

cada una de ellas inicia con un valor 0, como se observa en el listado 5.1.
#include <conio.h>
void main(void)
{
int matriz[3][4];
clrscr();
for(int x=0 ; x < 3 x++)
{
for(int y=0; y< 4 ; y++)
{
matriz[x][y]=x+y+1 ;
gotoxy(y+1,x+1);
cout<< matriz[x][y];
}
cout<<"\n";
}
getch();
}

Listado 5.1.- Arreglo con dos dimensiones.
El resultado de ejecutar el programa del listado 5.1 es el siguiente:
1234
2345
3456
El arreglo matriz puede representarse con la figura 5.3 .
Figura 5.3.- Representación del arreglo matriz .
Obsérvese que el primer subíndice varía de 0 a 2 y el segundo varía de 0 a 3.
En los párrafos anteriores, se ha mostrado la forma de asignar valores a cada uno de los
elementos de un arreglo una vez que se ha escrito su declaración. Aquí veremos la
manera de asignarle valores iniciales a los elementos, en la misma instrucción que
contiene la declaración del arreglo.
Por ejemplo, para declarar un arreglo de 10 enteros y al mismo tiempo asignarle a cada
uno de sus elementos los valores 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, puede escribirse:
int digitos[] = { 0,1,2,3,4,5,6,7,8,9 };
En este caso, aunque no se escribe el tamaño de la dimensión del arreglo digitos, tiene el
mismo efecto que escribir:

int digitos[10];
digitos[0] = 0 ;
digitos[1] = 1 ;
digitos[2] = 2 ;
digitos[3] = 3 ;
digitos[4] = 4 ;
digitos[5] = 5 ;
digitos[6] = 6 ;
digitos[7] = 7 ;
digitos[8] = 8 ;
digitos[9] = 9 ;
Como puede verse, la primera forma es mucho más compacta, aunque, como en muchas
de las instrucciones de C++, la brevedad del código sacrifica la claridad.
Ejercicios

mostrar estos números ingresados.
Dato de prueba:
columna1 columna2 columna3
Fila 1 14 35 46
Fila 2 25 18 49
int main()
{
int NUM[2][3];
int I, J;
for ( I=1; I<=2; I++)
{
cout<<"\n INGRESE 3 NUM. ENTEROS DE LA FILA "<<I<<"\n ";
for ( J=1; J<=3;J++)
cin>>NUM[I][J];
}
cout<<"\n LOS NUMEROS INGRESADOS SON: ";
cout<<"\n ";
for ( I=1; I<=2; I++)
{
for ( J=1; J<=3;J++)
cout<<NUM[I][J] <<" ";
cout<<"\n ";
}
cout<<"\n ";
system("PAUSE");
return 0;
}
mostrar la suma y promedio de estos números ingresados.
Dato de prueba:
columna1 columna2 columna3
Fila 1 14 35 46
Fila 2 25 18 49

3. Elabore un programa que permita aceptar 12 números enteros y seguidamente se debe
mostrar la suma de los valores de cada una de sus filas (por separado).
Dato de prueba:
columna1 columna2 columna3 columna 4
Fila 1 14 35 46 32
Fila 2 25 18 49 43
Fila 3 51 34 12 65
5.3.- Cadenas de caracteres
En C++ no existe un tipo predefinido para el manejo de cadenas de caracteres como en

otros lenguajes, sino que tienen que declararse como arreglos de caracteres.
Lo que distingue a una cadena de caracteres, con respecto a un arreglo de caracteres

cualquiera, es que la cadena de caracteres tiene como último carácter al carácter nulo \0.
Por ejemplo, si se declara el arreglo:
char cadena[8];
Podemos asignar los siguientes valores a cada uno de sus elementos:
cadena[0] = 'A' ;
cadena[1] = 'R' ;
cadena[2] = 'R' ;
cadena[3] = 'E' ;
cadena[4] = 'G' ;
cadena[5] = 'L' ;
cadena[6] = 'O' ;
cadena[7] = '\0';
Al contener el carácter nulo, el arreglo cadena será reconocido por las funciones y
objetos diseñados para manipular cadenas de caracteres. Para manejar un arreglo de
cadenas de caracteres se debe declarar como un arreglo bidimensional de elementos de
tipo char, como puede observarse en el listado 5.2.
#include <conio.h>
int main()
{
unsigned short int calif[10];
char nombre[10][21]; // Se declara un arreglo bidimensional
// para 10 nombres de 20 caracteres por
// nombre mas un caracter para el nulo.
clrscr();
for( int x=1 ; x <= 10 ; x++)
{
gotoxy(10,x+1);
cout << "NOMBRE [" << x << "] = " ;

cin >> nombre[x];
gotoxy(45,x+1);
cout << "CALIFICACION [" << x << "] = " ;
cin >> calif[x];
}
return 0;
}
Listado 5.2.- Manejo de un arreglo de cadenas de caracteres.
En el listado 5.2, se inicia con el subíndice 0 para no desperdiciar el primer elemento del
arreglo. Además, se debe recordar que el subíndice del último elemento del arreglo es
igual al tamaño de la dimensión menos 1.
5.4.- Asignación de Valores Iniciales a Cadenas
Cuando se tiene un arreglo de cadenas de caracteres, se puede utilizar la forma

compacta mostrada en la sección anterior, sólo que , en lugar de constantes numéricas
manejaríamos constantes de cadena.
Por Ejemplo:
char nombres[][5] = { "HUGO", "PACO", "LUIS" } ;
es equivalente a:
char nombres[3][5];
nombres[0] = "HUGO" ;
nombres[1] = "PACO" ;
nombres[2] = "LUIS" ;
Esto también puede manejarse a nivel de caracteres, así:
char nombres[][5] = { 'H','U','G','O','\0',

'P','A','C','O','\0',
'L','U','I','S','\0' };
o así:
char nombres[3][5];
nombres[0][0] = 'H' ;
nombres[0][1] = 'U' ;
nombres[0][2] = 'G' ;
nombres[0][3] = 'O' ;
nombres[0][4] = '\0' ;
nombres[1][0] = 'P' ;
nombres[1][1] = 'A' ;
nombres[1][2] = 'C' ;
nombres[1][3] = 'O' ;
nombres[1][4] = '\0' ;
nombres[2][0] = 'L' ;
nombres[2][1] = 'U' ;

nombres[2][2] = 'I' ;
nombres[2][3] = 'S' ;
nombres[2][4] = '\0' ;
En los listados 5.3 y 5.4 se muestran las dos primeras formas, observándose que se
obtiene el mismo resultado.
#include <conio.h>
void main()
{
char nombres[][5] = { "HUGO","PACO","LUIS" };
int calif[] = { 100, 90, 100 };
clrscr();
for( int x=0 ; x < 3;x++)
{
gotoxy(35,x+10);
cout<< nombres[x];
gotoxy(40,x+10);
cout << calif[x];
}
}
Listado 5.3.- Manejo de arreglos de cadenas.
#include <conio.h>
void main()
{
char nombres[][5] = { 'H','U','G','O','\0',
'P','A','C','O','\0',
'L','U','I','S','\0' };
int calif[] = { 100, 90, 100 };
clrscr();
for( int x=0 ; x< 3;x++)
{
gotoxy(35,x+10);
cout<< nombres[x];
gotoxy(40,x+10);
cout << calif[x];
}
}
Listado 5.4.- Manejo de arreglos bidimensionales de caracteres.
En los listados 5.3 y 5.4, se muestra que no es necesario escribir el valor de la primera
dimensión de los arreglos cuando, en su declaración, se asignan valores constantes a los
elementos.
La ventaja que tiene la forma mostrada en 5.3 y 5.4 es que, al no especificar una de las
dimensiones, la cantidad de cadenas a manejar puede variarse con sólo agregarlas a la
lista o eliminarlas de ella.
5.5.- Funciones para el manejo de cadenas

Como se estableció al principio de esta unidad, el lenguaje C++ no cuenta con algún
tipo de dato específico para el manejo de cadenas de caracteres, pero sí cuenta con un
grupo de funciones que se han acumulado durante la evolución del Lenguaje C.
Para leer una cadena de caracteres desde el teclado existe la función gets(), y para
desplegar una cadena en pantalla se usa la función puts(). Los prototipos de ambas
funciones se encuentran declarados en el archivo STDIO.H.
Por ejemplo, el listado 5.5 muestra un programa que sirve para leer y desplegar cadenas
de caracteres utilizando las funciones gets() y puts().
#include <stdio.h> // Para gets() y puts()

#include <conio.h> // Para clrscr() y gotoxy()
#include <string.h> // Para strupr() y strlen()
void main()
{
char nombre[31]; // Declara un arreglo de 31 caracteres
char saludo1[] = "?? HOLA,"; //Constante de caracteres
char saludo2[] = " !!";
clrscr();
gotoxy(20,10);
puts("¿ Cuál es tu nombre ? "); //Despliega cadena de car.
gotoxy(45,10);
gets(nombre); // Lee cadena de caracteres
strupr(nombre); // Convierte a mayúsculas
gotoxy(20,12);
puts(saludo1);
gotoxy(30,12);
puts(nombre);
gotoxy(30+strlen(nombre),12); // Longitud de la cadena
puts(saludo2);
}
Listado 5.5.- Lectura y desplegado de cadenas de caracteres.
Además de las funciones gets() y puts(), existe otro grupo de funciones para el manejo
de cadenas de caracteres, como strlen() y strupr() utilizadas en el programa del listado
5.5. Los prototipos de estas funciones se encuentran declarados en el archivo
STRING.H En la tabla 5.1 se describen brevemente algunas de las funciones para el
manejo de cadenas de caracteres en el C++ de Borland, cuyos prototipos se encuentran
declarados en el archivo STRING.H .
FUNCION DESCRIPCION
Copia una cadena de caracteres en otra.Se detiene cuando encuentra el
stpcpy
terminador nulo.
strcat Añade una cadena de caracteres a otra.
strchr Busca, en una cadena, un caracter dado.
strcmp Compara dos cadenas.
Macro que compara dos cadenas sin distinguir entre mayúsculas y
strcmpi
minúsculas.

strcpy Copia una cadena.
Busca segmentos que no contienen un subconjunto de un conjunto
strcspn
especificado de caracteres.
strdup Copia una cadena a una nueva localidad.
_strerror Genera un mensaje de error definido por el programador.
strerror Retorna el apuntador al mensaje asociado con el valor del error.
stricmp Compara dos cadenas sin diferenciar entre mayúsculas y minúsculas
strlen Determina la longitud de una cadena.
strlwr Convierte las mayúsculas de una cadena en minúsculas.
strncat Añade el contenido de una cadena al final de otra.
strncmp Compara parte de una cadena con parte de otra.
Compara parte de una cadena con parte de otra, sin distinguir entre
strncmpi
mayúsculas y minúsculas.
strncpy Copia un un número de bytes dados, desde una cadena hacia otra.
Compara parte de una cadena con parte de otra, sin distinguir entre
strnicmp
mayúsculas y minúsculas.
strnset Hace que un grupo de elementos de una cadena tengan un valor dado.
Busca la primera aparición, en una cadena, de cualquier caracter de un
strpbrk
conjunto dado.
strrchr Busca la última aparición de un caracter en una cadena.
strrev Invierte el orden de los caracteres de una cadena.
strset Hace que los elementos de una cadena tengan un valor dado.
Busca en una cadena el primer segmento que es un subconjunto de un
strspn
conjunto de caracteres dado.
strstr Busca en una cadena la aparición de una subcadena dada.
_strtime Convierte la hora actual a una cadena.
strtod Convierte una cadena a un valor double ó long double.
strtol Convierte una cadena a un valor long.
strtoul Convierte una cadena a un valor unsigned long.
strupr Convierte las minúsculas de una cadena a mayúsculas.
Tabla 5.1.- Funciones para el manejo de cadenas de caracteres.
Ejercicio 6 de IF
int main()
{

float N;
int NE;
cout<< "\n INGRESE UN NUMERO : " ; cin>>N;
NE = int(N);
if (N-NE==0)
cout<< "\n NUMERO INGRESADO ES ENTERO ";
cout<< "\n";
system("PAUSE");
return 0 ;
}
Ejercicio 7 de IF
int main()
{
int N;
if (N>0 && N%2==0)

cout<< "\n NUMERO INGRESADO ES PAR ";
cout<< "\n";
system("PAUSE");
return 0 ;
}
Ejercicio 8 de IF
int main()
{
float N;
int NE, H, M, S;
NE = int(N);
if (N-NE==0 && N>0)
{
H=NE/3600;
M=(NE%3600)/60;
S=(NE%3600)%60;
cout<<H<<" HORA(S) "<<M<<" MINUTO(S) "<<S<<" SEGUNDO(S)";
}
cout<< "\n";
system("PAUSE");
return 0 ;
}
Ejercicio 2 de IF- ELSE
int main()

{
int N, M;
cout<< "\n INGRESE " ;
cout<< "\n PRIMER NUMERO " ; cin>>N;
cout<< "\n SEGUNDO NUMERO DIFERENTE AL PRIMERO " ; cin>>M;
if (N!=M)
if (N>M)
cout<<"\n MAYOR NUMERO ES : "<<N;
else
cout<<"\n MAYOR NUMERO ES : "<<M;
else
cout<<"\n INGRESE NUMEROS DIFERENTES";
cout<< "\n";
system("PAUSE");
return 0 ;
}
int main()
{
int N;
int a, b, S, M;
cout<< "\n NUMERO ENTERO DE DOS CIFRAS " ; cin>>N;
if (N>=10 && N<=99)
{
a=N/10;
b=N%10;
if (a%2==0 && b%2==0)
{
S= a+b;
cout<<"\n LA SUMA DE LAS CIFRAS ES : "<<S;
}
if (a%2!=0 && b%2!=0)
{
M= a*b;
cout<<"\n EL PRODUCTO DE LAS CIFRAS ES : "<<M;
}
}
else
cout<<"\n INGRESE UN NUMERO DE DOS CIFRAS";
cout<< "\n";
system("PAUSE");
return 0 ;
}


int main()
{
int N;

cout<< "\n NUMERO ENTERO MENOR A 31524 : " ; cin>>N;
if (N>=0 && N<10)
cout<<"\n EL NUMERO TIENE UNA CIFRA ";
else if (N<100)
cout<<"\n EL NUMERO TIENE DOS CIFRAS ";
else if (N<1000)
cout<<"\n EL NUMERO TIENE TRES CIFRAS ";
else if (N<10000)
cout<<"\n EL NUMERO TIENE CUATRO CIFRAS ";
else if (N<31524)
cout<<"\n EL NUMERO TIENE CINCO CIFRAS ";
cout<< "\n";
system("PAUSE");
return 0 ;
}
int main()
{
int N;
int a, b, NC;
cout<< "\n NUMERO ENTERO DE DOS CIFRAS " ; cin>>N;
if (N>=10 && N<=99)
{
a=N/10;
b=N%10;
NC= a+b*10;
cout<<"\n EL NUMERO CON LAS CIFRAS CAMBIADAS ES : "<<NC;
}
else
cout<<"\n INGRESE UN NUMERO DE DOS CIFRAS";
cout<< "\n";
system("PAUSE");
return 0 ;
}
int main()
{
char COD[5], NOM[10];
int SB, AI, NH;// SUELDO BASICO, AÑO DE INGRESO, NUMERO DE HIJOS
int AS, BA, BH, SBRUTO;

float DES, SNETO;
cout<< "\n INGRESE DATOS DEL TRABAJADOR " ;
cout<< "\n CODIGO: " ; cin>>COD;
cout<< "\n NOMBRE: " ; cin>>NOM;
cout<< "\n SUELDO BASICO: " ; cin>>SB;
cout<< "\n AÑO DE INGRESO: " ; cin>>AI;
cout<< "\n NUMERO DE HIJOS: " ; cin>>NH;
AS= 2012-AI;
if (AS>8)
BA=10*AS;
else
BA=4*AS;
if (NH<4)
BH=8*NH;
else
BH=20;
SBRUTO=SB + BA + BH;
if (SBRUTO>1500)
DES=0.015*SBRUTO;
else
DES=0.005*SBRUTO;
SNETO=static_cast<float>(SBRUTO) - DES;
cout<<"\n ";
cout<<"\n RESULTADOS";
cout<< "\n";
cout<< "\n BONIFICACION POR AÑOS DE SERVICIO: "<<BA;
cout<< "\n BONIFICACION POR HIJOS: "<<BH;
cout<< "\n SUELDO BRUTO: "<<SBRUTO;
cout<< "\n DESCUENTO: "<<DES;
cout<< "\n SUELDO NETO: "<<SNETO;
cout<< "\n";
system("PAUSE");
return 0 ;
}
int main()
{
int N;

cout<< "\n NUMERO ENTERO : " ; cin>>N;
if (N<0 )
cout<<"\n EL NUMERO ES NEGATIVO ";
else if (N==0)
cout<<"\n EL NUMERO ES IGUAL A CERO ";
else
cout<<"\n EL NUMERO ES POSITIVO ";
cout<< "\n";

system("PAUSE");
return 0 ;
}
int main()
{
int A, B, C;
int M, N;
cout<< "\n INGRESE TRES NUMEROS DIFERENTES" ;
cout<< "\n PRIMER NUMERO : " ; cin>>A;
cout<< "\n SEGUNDO NUMERO : " ; cin>>B;
cout<< "\n TERCER NUMERO : " ; cin>>C;
if (A>B && A>C )
{
M=A;
if (B>C)
N=C;
else
N=B;
}
else if (B>A && B>C)
{
M=B;
if (A>C)
N=C;
else
N=A;
}
else
{
M=C;
if (A>B)
N=B;
else
N=A;
}
cout<<"\n EL MAYOR NUMERO INGRESADO ES : "<<M;
cout<<"\n EL MENOR NUMERO INGRESADO ES : "<<N;
cout<< "\n";
system("PAUSE");
return 0 ;
}
Ejercicio 9A de IF- ELSE

int main()

{
int A, B, C;
int M, N;
cout<< "\n INGRESE TRES NUMEROS DIFERENTES" ;
cout<< "\n PRIMER NUMERO : " ; cin>>A;
cout<< "\n SEGUNDO NUMERO : " ; cin>>B;
cout<< "\n TERCER NUMERO : " ; cin>>C;
if (A>B && A>C )
M=A;
else if (B>A && B>C )
M=B;
else
M=C;
if (A<B && A<C )
N=A;
else if (B<A && B<C )
N=B;
else
N=C;
cout<<"\n EL MAYOR NUMERO INGRESADO ES : "<<M;
cout<<"\n EL MENOR NUMERO INGRESADO ES : "<<N;
cout<< "\n";
system("PAUSE");
return 0 ;
}
Ejercicio switch01
#include<iostream.h>
int main()
{
int N;
cout<<"\n ";
cout<<"\n Numero desde 1 hasta 7 : "; cin>>N;
switch (N)
{
case 1:
cout<<"\n Lunes ";
break;
case 2:
cout<<"\n Martes ";
break;
case 3:
cout<<"\n Miercoles ";
break;
case 4:
cout<<"\n Jueves ";
break;
case 5:
cout<<"\n Viernes ";

break;
case 6:
cout<<"\n Sabado ";
break;
case 7:
cout<<"\n Domingo ";
break;
default:
cout<<"\n No existe el dia ";
}
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio switch02
int main()
{
int N;
cout<<"\n ";
cout<<"\n Numero desde 1 hasta 12 : "; cin>>N;
switch (N)
{
case 1:
case 2:
case 3:
cout<<"\n VERANO ";
break;
case 4:
case 5:
case 6:
cout<<"\n OTOÑO ";
break;
case 7:
case 8:
case 9:
cout<<"\n INVIERNO ";
break;
case 10:
case 11:
case 12:
cout<<"\n PRIMAVERA ";
break;
default:
cout<<"\n No existe el MES para el numero ingresado ";
}
cout<<"\n \n \n ";

system("PAUSE");
return 0;
}
Ejercicio switch03
int main()
{
int A, B;
char OP;
float RESULTADO;
cout<<"\n ";
cout<<"\n PRIMER NUMERO : "; cin>>A;
cout<<"\n SEGUNDO NUMERO : "; cin>>B;
cout<<"\n OPERADOR (+ , - , * , / ) : "; cin>>OP;
switch (OP)
{
case '+':
RESULTADO= A+B;
cout<<"\n LA SUMA ES: "<<RESULTADO;
break;
case '-':
RESULTADO= A-B;
cout<<"\n LA RESTA ES: "<<RESULTADO;
break;
case '*':
RESULTADO= A*B;
cout<<"\n LA MULTIPLICACION ES: "<<RESULTADO;
break;
case '/':
if (A!=0 && B!=0)
{
RESULTADO= static_cast<float>(A)/static_cast<float>(B);
cout<<"\n EL COCIENTE ES: "<<RESULTADO;
}
else cout<<"\n no se puede dividir entre cero ";
break;
default:
cout<<"\n No existe el MES para el numero ingresado ";
}
cout<<"\n \n \n ";
system("PAUSE");
return 0;
}
Ejercicio switch04

int main()
{
int SW=1;
int SB;
char CAT;
float DES, BON, PAGO;
cout<<"\n ";
cout<<"\n SUELDO BASICO : "; cin>>SB;
cout<<"\n CATEGORIA (A , B , C ) : "; cin>>CAT;
switch (CAT)
{
case 'A':
DES= SB*0.03;
PAGO= SB-DES;
break;
case 'B':
BON= SB*0.01;
PAGO= SB+BON;
break;
case 'C':
BON= SB*0.02;
PAGO= SB+BON;
break;
default:
cout<<"\n No existe la categoria ";
SW=0;
}
if (SW==1)
cout<<"\n PAGO : "<<PAGO;
cout<<"\n \n \n ";
system("PAUSE");
return 0;
}
Ejercicio switch05
int main()
{
int SWU,SWD,SWC=1;
int N;
int U, D, C;

cout<<"\n ";
cout<<"\n NUMERO ENTERO DE TRES CIFRAS : "; cin>>N;
if (N>99 && N<1000)
{
C= N/100;
D= (N%100)/10;
U= (N%100)%10;
switch(U)
{
case 0:
case 1:
case 4:
case 9:
cout<<"\n LA CIFRAS: "<<U<<" TIENE RAIZ CUADRADA EXACTA";
break;
default:
SWU=0;
}
switch(D)
{
case 0:
case 1:
case 4:
case 9:
cout<<"\n LA CIFRAS: "<<D<<" TIENE RAIZ CUADRADA EXACTA";
break;
default:
SWD=0;
}
switch(C)
{
case 0:
case 1:
case 4:
case 9:
cout<<"\n LA CIFRAS: "<<C<<" TIENE RAIZ CUADRADA EXACTA";
break;
default:
SWC=0;
}
}
else
cout<<"\n EL NUMERO DEBE SER DE TRES CIFRAS";
if (SWU==0 && SWD==0 && SWC==0)

cout<<"\n LA CIFRAS DEL NUMERO NO TIENEN RAIZ CUADRADA EXACTA";
cout<<"\n \n \n ";
system("PAUSE");
return 0;
}

Ejercicio WHILE02
int main()
{
int N;
int I, S;
cout<<"\n ";
cout<<"\n Numero limite para la suma: "; cin>>N;
I = 2;
S = 0;
while ( I < N)
{
I = I +2;
}
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio WHILE03
int main()
{
int N;
int I, C;
cout<<"\n ";
cout<<"\n Numero limite para contar los valores: "; cin>>N;
I = 2;
C = 0;
while ( I < N)
{
C = C + 1; // hacemos uso de un CONTADOR
I = I +2;
}
cout<<"\n EL TOTAL DE NUMERO ES : "<<C;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio WHILE04
int main()
{
int N1, N2;

int I, C;
cout<<"\n ";
cout<<"\n Numero limite inferior para contar los valores: "; cin>>N1;
cout<<"\n Numero limite superior para contar los valores: "; cin>>N2;
if (N1%2==0)
I=N1;
else
I=N1+1;
C = 0;
while ( I <= N2)
{
I = I +2;
}
cout<<"\n EL TOTAL DE NUMERO ES : "<<C;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio WHILE05
int main()
{
int N;
int I, S, M;
cout<<"\n ";
cout<<"\n Numero limite para contar los valores: "; cin>>N;
I = 3;
S = 0;
M = 1;
while ( I < N)
{
S = S + I; // hacemos uso de un Acumulador
M = M*I; // hacemos uso de una multiplicacion
I = I +3;
}
cout<<"\n LA SUMA ES : "<<S;
cout<<"\n EL PRODUCTO ES : "<<M;
cout<<"\n ";
system("PAUSE");
return 0;
}

Ejercicio WHILE06
int main()
{
int N;
int C, S, M;
cout<<"\n ";
cout<<"\n NUMERO ENTERO: "; cin>>N;
S=0;
M=1;
while (N!=0)
{
C=N%10;
S=S+C;
M=M*C;
N=N/10;
}
cout<<"\n EL PRODUCTO ES : "<<M;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio WHILE07
int main()
{
int N;
int C, S;
cout<<"\n ";
S=0;
while (N!=0)
{
C=N%10;
if(C%2!=0)
S=S+C;
N=N/10;
}
cout<<"\n ";
system("PAUSE");
return 0;
}

Ejercicio WHILE08
int main()
{
int N;
int C, D, S1, S2, SW;
cout<<"\n ";
S1=0;
S2=0;
SW=0;
while (N!=0)
{
C=N%10;
if(SW==0)
{
S1= S1 + C;
SW=1;
}
else
{
S2= S2 + C;
SW=0;
}
N=N/10;
}
D= S1-S2;
cout<<"\n LA DIFERENCIA ES : "<<D;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio WHILE09
#include <math.h>
int main()
{
int N, B;
int R, I;
double NC;
cout<<"\n ";
cout<<"\n NUMERO ENTERO EN EL SISTEMA DECIMAL: "; cin>>N;
cout<<"\n LA BASE DEL NUEVO SISTEMA DE NUMERACION: "; cin>>B;
NC=0;
I=0;

while (N!=0)
{
R=N%B;
NC=NC + R*pow(10,I);
I=I+1;
N=N/B;
}
cout<<"\n EL NUMERO EN LA BASE "<<B<<" ES : "<<NC;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio DO_WHILE03
int main()
{
int N;
int I, S, C;
cout<<"\n ";
cout<<"\n Numero limite: ";cin>>N;
S = 0;
C = 0;
I = 5;
do
{
S = S + I;
C = C +1;
I = I + 5;
}
while ( I <= N);
cout<<"\n La Cantidad de numeros sumados es: "<<C;
cout<<"\n ";
system("PAUSE");
return 0;
}
int main()
{
float A, L, B, H, R, b;
int OP;
int Resp;
do
{

cout<<"\n Que Area desea determinar ";
cout<<"\n 1. Cuadrado ";
cout<<"\n 2. Tiangulo ";
cout<<"\n 3. Circulo ";
cout<<"\n 4. Trapecio ";
cout<<"\n Opcion "; cin>>OP;
switch (OP)
{
case 1:
cout<<"\n El lado "; cin>>L;
A = L*L;
cout<<"\n El area del cuadrado es : "<<A;
break;
case 2:
cout<<"\n La Base "; cin>>B;
cout<<"\n La Altura "; cin>>H;
A = B*H;
cout<<"\n El area del Triangulo es : "<<A;
break;
case 3:
cout<<"\n El radio ";cin>>R;
A = 3.1415*R*R;
cout<<"\n El area del Circulo es : "<<A;
break;
case 4:
cout<<"\n La Base mayor "; cin>>B;
cout<<"\n La Base menor "; cin>>b;
cout<<"\n La Altura "; cin>>H;
A = ((B+b)/2)*H;
cout<<"\n El area del Trapecio es : "<<A;
break;
default:
cout<<"\n Opcion Incorrecta ";
}
cout<<"\n Desea Continuar SI = 9 / NO = 0? ";cin>>Resp;
} while ( Resp == 9);
cout<<"\n ";
system("PAUSE");
return 0;
}
int main()
{
int N;
int C, I, F, MAYOR=0;

cout<<"\n ";
do
{
C=N%10;
if (C > MAYOR)
MAYOR=C;
N=N/10;
}while (N!=0);
F=1;
I=1;
do
{
F=F*I;
I=I+1;
}while (I<=MAYOR);
cout<<"\n El factorial de la mayor cifra es : "<<F;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio FOR02
int main()
{
int N;
int I, S;
cout<<"\n ";
S = 0;
for ( I = 2; I <= N; I=I+2)
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio FOR03
int main()
{
int N1, N2;
int I, C;
cout<<"\n ";

cout<<"\n Numero limite inferior del rango : ";cin>>N1;
cout<<"\n Numero limite superior del rango : ";cin>>N2;
C = 0;
for ( I = N1; I <= N2; I++)
if(I%5==0)
cout<<"\n El total de numeros multiplos de 5 es: "<<C;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio FOR04
int main()
{
int N;
int C, I;
cout<<"\n ";
cout<<"\n NUMERO ENTERO : "; cin>>N;
C=0;
for(I=1; I<=N; I++)
if (N%I==0)
C=C+1;
if(C==2)
cout<<"\n El numero "<<N<<" es un numero primo absoluto";
else
cout<<"\n El numero "<<N<<" NO es un numero primo absoluto";
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio FOR05
int main()
{
int N;
int A, S, T, I;
cout<<"\n ";
cout<<"\n NUMERO ENTERO QUE LIMITA LA SERIE DE FIBONACCI : "; cin>>N;
A=0;
S=1;
cout<<"\n "<<A<<";"<<S;
for(I=3; I<=N; I++)

{
T= A+ S;
cout<<";"<<T;
A=S;
S=T;
}
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio FUNCION02
//función que permite sumar, restar, multiplicar y dividir dos números enteros
float operacion(int A, int B, char OP)
{
float RESULTADO;
switch (OP)
{
case '+':
RESULTADO= A+B;
break;
case '-':
RESULTADO= A-B;
break;
case '*':
RESULTADO= A*B;
break;
case '/':
if (A!=0 && B!=0)
{
RESULTADO= static_cast<float>(A)/static_cast<float>(B);
}
break;
}
return RESULTADO;
}
// fin de la función
int main()
{
int X, Y;
char O;
float RESUL;
cout<<"\n ";
cout<<"\n Primer numero : ";cin>>X;
cout<<"\n Segundo numero : ";cin>>Y;

O='+';
RESUL= operacion(X, Y, O); //Se invoca a la funcion
cout<<"\n La suma es : "<<RESUL;
O='-';
cout<<"\n La resta es : "<<RESUL;
O='*';
cout<<"\n La multiplicacion es : "<<RESUL;
O='/';
cout<<"\n La division es : "<<RESUL;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio ARREGLO03
int main()
{
int NUM[10];
int I, S;
float PROM;
cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n ";
//SUMANDO LOS ELEMENTOS
S=0;
for ( I=1; I<=10;I++)
S = S + NUM[I];
// PROMEDIO
PROM = static_cast<float>(S)/10;
cout<<"\n LA SUMA ES: "<<S;
cout<<"\n EL PROMEDIO ES: "<<PROM;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio ARREGLO06
int main()
{
int NUM[10];
int I, J, AUX, MENOR;

float RESULTADO;
cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n ";
// haciendo uso del metodo de la burbuja
for ( I=1; I<=9;I++)
for ( J=I + 1; J<=10;J++)
if (NUM[J] < NUM[I])
{
AUX = NUM[I];
NUM[I]= NUM[J];
NUM[J]= AUX;
}
cout<<"\n ";
//DETERMINAR EL NUMERO MENOR DIFERENTE DE CERO
for ( I=1; I<=10;I++)
if (NUM[I]!=0)
{
MENOR=NUM[I];
break;
}
RESULTADO= static_cast<float>(NUM[10])/static_cast<float>(MENOR);
cout<<"\n EL RESULTADO DE LA DIVISION ES: "<<RESULTADO;
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio ARREGLO08
int main()
{
int NUM[10], PRI[10], NPRI[10];
int I, J, C;
int K=1, N=1;
cout<<"\n ";
for ( I=1; I<=10;I++)
cin>>NUM[I];
cout<<"\n ";
for ( I=1; I<=10;I++)
{
PRI[I]=0;
NPRI[I]=0;
}
// DETERMINANDO LOS PRIMOS ABSOLUTOS
for ( I=1; I<=10;I++)
{

C=0;
for ( J=1; J<=NUM[I];J++)
if(NUM[I]%J==0)
C=C+1;
if (C==2)
{
PRI[K]=NUM[I];
K=K+1;
}
else
{
NPRI[N]=NUM[I];
N=N+1;
}
}
// PRESENTAR LOS VECTORES
for ( I=1; I<=10;I++)
cout<<PRI[I]<<" ";
cout<<"\n ";
for ( I=1; I<=10;I++)
cout<<NPRI[I]<<" ";
cout<<"\n ";
system("PAUSE");
return 0;
}
Ejercicio ARREGLOBI03A
int main()
{
int NUM[3][4];
int I, J, S;
for ( I=1; I<=3; I++)

{
for ( J=1; J<=4;J++)
cin>>NUM[I][J];
}
// sumado los numerous por fila
for ( I=1; I<=3; I++)

{
S=0;
for ( J=1; J<=4;J++)
S= S + NUM[I][J];
cout<<"\n suma de la fila "<<I<<" es :"<<S;
}
cout<<"\n ";
system("PAUSE");

return 0;
}
Ejercicio ARREGLOBI03B
int main()
{
int NUM[3][4];
int S[3];
int I, J;
for ( I=1; I<=3; I++)

{
for ( J=1; J<=4;J++)
cin>>NUM[I][J];
}
// sumado los numeros por fila
for ( I=1; I<=3; I++)

{
S[I]=0;
for ( J=1; J<=4;J++)
S[I]= S[I] + NUM[I][J];
}
//mostrar la matriz con los resultados por fila
for ( I=1; I<=3; I++)
{
for ( J=1; J<=4;J++)
cout<<NUM[I][J]<<" ";
cout<<S[I]<<"\n ";
}
cout<<"\n ";
system("PAUSE");
return 0;
}

Idioma

Programacion en Lenguaje de Alto Nivel 1

Cargado por

Información del documento

Descripción:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Descripción:

Copyright:

Formatos disponibles

Programacion en Lenguaje de Alto Nivel 1

Cargado por

Descripción:

Copyright:

Formatos disponibles

1.

Estructura de un programa en C++

1.1 El formato general de un programa en C++ es el siguiente:

void main(void) <---linea de cabecera de la función principal.

En el listado 1.1 se muestra un programa que despliega en la pantalla del monitor

#include <stdio.h> // Para utilizar la función printf()

Listado 1.1.- Primer programa en C++

1.2.- Archivos de cabecera.

El listado 1.1 contiene la línea :

En ella, stdio.h es el nombre de un archivo de cabecera en el cual se encuentran declarados los

Docente: Ing. CIP Roberto Carlos Román Anaya 1

En el C++ existen dos formas de manejar los comentarios:

/* Este es otro comentario, pero a diferencia del

Observe que también puede incluir líneas en blanco (como la anterior y la

void main(void) // Este comentario ocupa parte de la línea.

// Primer comentario de una sola línea.

// Segundo comentario de una sola línea.

*/ Fin del comentario de varias líneas.

1.4.- Directivas del preprocesador

El preprocesador es un programa que viene incluido en los compiladores de C++, y se encarga

Las directivas del preprocesador pueden clasificarse en tres grupos principales:

1.4.1.- Inclusión de archivos

Docente: Ing. CIP Roberto Carlos Román Anaya 2

1.4.2.- Reemplazamiento de cadenas y procesamiento de macros

El reemplazamiento de cadenas consiste en sustituir (antes de efectuar la compilación) cada

#define VALMAX 1000

Esta macro puede utilizarse en una instrucción de la siguiente forma:

El preprocesador sustituye lo anterior por:

#define REDOND(x) ((x)>=0?((x)+1/VALOR1)*(1-1/VALOR1): \

Docente: Ing. CIP Roberto Carlos Román Anaya 3

1.5.- La Función main()

Al invocar a un programa escrito en C++, desde el indicador de presencia del sistema

1.6.1.- Identificadores creados por el usuario

Reglas generales para los identificadores:

a.- Letras mayúsculas y/o minúsculas.

Docente: Ing. CIP Roberto Carlos Román Anaya 4

3.- Pueden contener un número arbitrario de caracteres; pero Borland C++

4.- Se toma en cuenta la diferencia entre letras mayúsculas y minúsculas,

5.- No puede utilizarse el mismo identificador para dos objetos que se

1.6.2.- Palabras reservadas

La tabla 1.1 muestra las palabras reservadas de Borland C++

Tabla 1.1.- Palabras reservadas de Borland C++.

En el Lenguaje C++, la entrada/salida se maneja de dos formas.

La primera consiste en la utilización de las funciones cuyos prototipos vienen declarados en el

La segunda es propia del C++ y consiste en el manejo de objetos y operadores cuyas

Docente: Ing. CIP Roberto Carlos Román Anaya 5

1.7.1.- Funciones declaradas en stdio.h

1.7.1.1.- La función printf()

Esta función es la mas utilizada en C para desplegar información en la pantalla, más no en el

El formato general para la función printf() es:

printf(<cadena_formato> , <elem> , <elem> , ... );

cadena_formato es una cadena de caracteres encerrada entre comillas

La sustitución de los elementos se hace de acuerdo a los comandos de formato incluidos en

En la tabla 1.2 se muestran los comandos de formato más usuales:

Comando Sirve para:

Tabla 1.2.- Comandos de formato.

Docente: Ing. CIP Roberto Carlos Román Anaya 6

Tabla 1.3.- Tipos de datos, tamaños y rangos en Borland C++ 3.1

1.7.1.2.- La función scanf()

Esta función toma la entrada, normalmente del teclado, y la almacena en variables