Universidad de Oriente

Núcleo Anzoátegui
Extensión Centro Sur Anaco
Escuela de Ingeniería y Cs. Aplicadas
Departamento de Ingeniería Industrial

Unidad II: Lenguajes de Programación

Lenguaje de Programación C++

Profesor: Integrantes:
Eduardo Correa Campos Daniel, C.I.: 26.313.001
Procesamiento de Datos González Jhonatan, C.I.: 25.428.914
Sección 02 González María Laura, C.I.: 25.434.020
Hernández Jorge, C.I.: 25.994.559
Lira Paola, C.I.: 26.947.112

Anaco, Febrero 2018

 Índice
Introducción ..................................................................................................................................................
Lenguaje de Programación C++ ................................................................................................................. 4
1. Aspectos básicos. ............................................................................................................................. 4
2. Historia y Origen.............................................................................................................................. 4
3. Entornos de Desarrollo. ................................................................................................................... 5
3.1. Principales IDE para C++ ......................................................................................................... 6
4. Usos.................................................................................................................................................. 7
5. Fundamentos de Programación. ....................................................................................................... 8
5.1. Tipos Simples. .......................................................................................................................... 8
6. Entrada y Salida de Datos Básica .................................................................................................. 11
7. Estructuras de Control.................................................................................................................... 11
7.1. Sentencia, Secuencia y Bloque ............................................................................................... 11
7.2. Declaraciones Globales y Locales .......................................................................................... 12
7.3. Sentencias de Selección .......................................................................................................... 12
7.4. Sentencias de Iteración. Bucles .............................................................................................. 12
7.5. Programación Estructurada..................................................................................................... 13
8. Subprogramas. Funciones y Procedimientos. ................................................................................ 13
8.1. Funciones y Procedimientos. .................................................................................................. 13
8.2. Definición de Subprogramas .................................................................................................. 15
8.3. Ejecución de Subprogramas ................................................................................................... 17
9. Arrays y Cadenas ........................................................................................................................... 17
9.1. Declaración ............................................................................................................................. 18
9.2. Asignación de Valores ............................................................................................................ 18
10. Estructuras de Entrada y Salida por Archivos en C++ ............................................................... 20
10.1. Iostream.H ........................................................................................................................... 20
10.2. Operaciones de Salida. ........................................................................................................ 21
10.3. Operaciones de Entrada ...................................................................................................... 22
11. Ejemplo. ..................................................................................................................................... 24
Conclusión ....................................................................................................................................................
Bibliografía ...................................................................................................................................................
 Introducción
Los avances tecnológicos que han surgido desde comienzos del siglo XXI han influido en
muchos aspectos de nuestra vida cotidiana, específicamente en la manera de cómo comunicarnos tanto
con otras personas como con los equipos tecnológicos que usamos en nuestro día a día. Esto último ha
evolucionado gracias a la influencia de los lenguajes de programación, que brindan un modo practico
para que lo seres humanos puedan indicarle instrucciones a un equipo. Con la llegada de estos lenguajes
se puso en evidencia que mediante una serie de comandos se podían establecer un conjunto de reglas
sintácticas y semánticas para definir su estructura y el significado de sus elementos, respectivamente.
Hoy en día existen una gran variedad de lenguajes de programación, esto ha permitido que
desarrolladores puedan ofrecer programas y aplicaciones más complejas y completas que ayudaran a
facilitar las actividades que se desempeñan a diario.
 Unidad II - Lenguajes de Programación:

Lenguaje de Programación C++

1. Aspectos básicos.

C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup.
La intención de su creación fue el extender al lenguaje de programación C mecanismos que permiten la
manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el
C++ es un lenguaje híbrido. Posteriormente se añadieron facilidades de programación genérica, que se
sumaron a los paradigmas de programación estructurada y programación orientada a objetos. Por esto se
suele decir que el C++ es un lenguaje de programación multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.
Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear nuevos tipos
que se comporten como tipos fundamentales. El nombre "C++" fue propuesto por Rick Mascitti en el
año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se
había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se
refiere a que C++ es una extensión de C.

2. Historia y Origen.

Su origen data del año 1979 y se le atribuye a Bjarne Stroustrup. El lenguaje que inspiró a Stroustrup
fue el lenguaje Simula (lenguaje usado para simulaciones), que es considerado el primer lenguaje en
permitir programación orientada a objetos. Stroustrup considero que esta funcionalidad del lenguaje
Simula era muy útil en el desarrollo de software, pero Simula era muy lento para un uso práctico.

Stroustrup comenzó a trabajar en su lenguaje llamado “C with classes” (C con clases) , su meta era
agregar programación orientada a objetos al lenguaje C. El primer compilador de este lenguaje fue
Cfront (un compilador escrito en C with classes) derivado del compilador de lenguaje C llamado CPre,
aunque en 1993 se dejaría de usar por la dificultad para agregar nuevas funciones. En 1983 el nombre
del lenguaje fue cambiado de “C with classes” a “C++”. Podemos entender con esto la imagen que tenía
Stroustrup de su lenguaje como una mejora del lenguaje “C” (al ser ++ un incrementador de variable).
 Para 1985 Stroustrup publicó su referencia al lenguaje “The C++ Programming Language” (“El
lenguaje de programación C++), el cual fue muy importante debido a la falta de estandarización del
lenguaje recién creado. En 1990 se publicó “The Annotated C++ Reference Manual” (Manual de
referencia anotada de C++) y ese mismo año salió al mercado el compilador “Turbo C++” (desarrollado
por Borland Software Corporation) que agregaba una gran cantidad de nuevas librerías al lenguaje,
ayudando a su desarrollo. El proyecto de librerías “Boost” agrego nuevas funcionalidades al lenguaje
tales como aleatorización comprehensiva y una nueva librería de tiempo.

En 1998 el “Comité de estándares de C++” publicó su primera estandarización internacional

ISO/IEC 14882:1998 (conocida también como C++98) la cual, al tener varios problemas, fue
actualizada en 2003 (C++03). En 2011 se terminó y publicó la nueva estandarización del lenguaje
(C++11).

3. Entornos de Desarrollo.

Un entorno de desarrollo integrado o entorno de desarrollo interactivo, en inglés Integrated

Development Environment (IDE), es una aplicación informática que proporciona servicios integrales
para facilitarle al desarrollador o programador el desarrollo de software. Normalmente, un IDE consiste
de un editor de código fuente, herramientas de construcción automáticas y un depurador. La mayoría de
los IDE tienen auto-completado inteligente de código (IntelliSense). Algunos IDE contienen un
compilador, un intérprete, o ambos, tales como NetBeans y Eclipse; otros no, tales como SharpDevelop
y Lazarus. El límite entre un IDE y otras partes del entorno de desarrollo de software más amplio no está
bien definido. Muchas veces, a los efectos de simplificar la construcción de la interfaz gráfica de usuario
(GUI, por sus siglas en inglés) se integran un sistema controlador de versión y varias herramientas.
Muchos IDE modernos también cuentan con un navegador de clases, un buscador de objetos y un
diagrama de jerarquía de clases, para su uso con el desarrollo de software orientado a objetos.

En definitiva un IDE es más que un simple editor de texto, es una suite de componentes o módulos
que permiten no solo escribir código fuente, sino también generar con él un programa ejecutable, aunque
también es posible encontrar entornos de desarrollo integrados, que no contienen un compilador
incorporado en sí mismos, sin embargo, por lo general pueden configurarse para trabajar en conjunto
con uno de ellos, para así poder producir un archivo ejecutable, a no ser que el lenguaje que se esté
empleando no requiera compilación.

Tanta es la simbiosis que se da entre algunos IDE y sus compiladores, que muchos informáticos
noveles, suelen confundir ambas cosas y la realidad es que se trata de programas distintos, pues el
compilador es el software encargado de traducir (compilar) el código fuente a lenguaje maquina (código
binario), por lo tanto es una más de las herramientas que integran un entorno de desarrollo.

En el caso del lenguaje C y su evolución orientada a objetos, el C++, los compiladores más
conocidos son GCC (GNU Compiler Collection), MinGW (implementación de GCC para Windows), los
antiguos Turbo C y Turbo C++ que eran tanto compiladores como IDE para el sistema operativo MS-
DOS y fueron descontinuados, siendo sustituidos por C++Builder, y Visual C++ (que forma parte de
Visual Studio).

3.1. Principales IDE para C++

Algunos de los compiladores mencionados anteriormente, pueden emplearse en combinación con

algunos de los IDE que mencionare a continuación, otros ya poseen su propio compilador incorporado.
En cualquier caso, los IDE más utilizados en la programación con C++, son los siguientes:

 Dev-C++: Este emplea el compilador MinGW y esta creado mediante el Entorno Delphi y
el lenguaje Object Pascal, se trata de un software libre, sencillo, ligero y eficiente, para la
plataforma Windows, que cuenta con un arsenal de herramienta que permiten la
programación rápida de aplicaciones complejas. Actualmente está desactualizado, también
existen variantes de este IDE como wxDev C++ que integra características extra para la
creación de interfaces.
 Code::Blocks: Es una alternativa a Dev-C++ que ha sido desarrollada mediante el propio
lenguaje C++, también es un software libre, pero en este caso es multiplataforma. Sus
capacidades son bastante buenas y es muy popular entre los nuevos programadores. Se
puede encontrar separado del compilado o la versión “mingw” que incluye g++ (GCC para
C++).
 Visual C++: Como ya he mencionado, se trata tanto de un módulo del entorno Visual
Studio como un compilador, posee editor de interfaces gráficas y una serie de asistentes
 que hacen muy cómodo el proceso de desarrollo. En realidad el lenguaje que se emplea es
un dialecto de C++ compatible con la plataforma .NET de Microsoft.
 C++Builder: Esta es la opción desarrollada por Borland (antigua líder en producción de
compiladores C++) y actualmente propiedad de la empresa Embarcadero Technologies, es
un software propietario y de pago, destinado a la plataforma Windows.
 NetBeans: Este IDE libre y multiplataforma, está destinado originalmente a la
programación mediante el lenguaje Java, sin embargo con la implementación un paquete de
software adicional, puede emplearse para desarrollar mediante C/C++.
 Eclipse: Al igual que el anterior, su principal propósito es programar mediante Java pero
puede expandirse para soportar C++ y también es tanto libre como multiplataforma.
 MonoDevelop: Esta es una alternativa a Visual Studio, no tan conocida como su
competidor, pues sus características son similares, pero este IDE es multiplataforma y de
software libre. Posee un editor de interfaces graficas que implementa la biblioteca GTK y
es compatible con el .Net Framework de Microsoft.
 Xcode: Para la plataforma Mac este es el IDE más utilizado, trabaja en combinación con el
compilador GCC y con Interface Builder, este último es un diseñador de interfaz gráfica
que facilita el diseño mediante el proceso de arrastrar y soltar controles en un espacio de
trabajo.
 KDevelop: Este software de desarrollo está destinado exclusivamente a su uso en la
plataforma GNU/Linux y otros sistemas Unix, no cuenta con un compilador propio por lo
que requiere de su integración con GCC. Está dirigido al escritorio KDE aun cuando puede
emplearse en otros entornos.
 Anjuta: Esta opción es propia de los sistemas GNU/Linux y BSD, en este caso su propósito
principal es desarrollar aplicaciones para el escritorio GNOME mediante las herramientas
proporcionadas por GTK+.

4. Usos.

A pesar de que el leguaje C++ hasta hace unos años se ubicaba en tercer lugar dentro de los
lenguajes de programación más usados (superado solamente por C y Java respectivamente), no es muy
utilizado en el desarrollo de apps o páginas web, limitándose al desarrollo de softwares de teléfonos
como el Windows Phone. Muchos de los desarrolladores que recientemente han incursando en el
desarrollo de páginas web, aplicaciones y software prefieren usar otro de los lenguajes de programación
existentes en lugar de C++ a pesar de la flexibilidad y las capacidades que este ofrece.

5. Fundamentos de Programación.
5.1.Tipos Simples.

Un programa trabaja con datos con unas determinadas características. No es lo mismo procesar
números naturales, números reales o nombres (cadenas de caracteres). En cada caso tratamos con datos
de tipo diferente. C++ dispone de un número reducido de tipos predefinidos y es importante elegir en
cada caso aquel que mejor se adapta a los datos que deseamos manipular. Por ejemplo, en nuestro
programa euros.cpp hicimos uso del tipo double porque nuestro objetivo era manipular datos numéricos,
posiblemente con decimales. También es posible definir nuevos tipos, con características no
predefinidas sino pensadas específicamente para un determinado programa.

La elección de un determinado tipo u otro para una determinada entidad del programa proporciona
información acerca de:

 El rango de posibles valores que puede tomar.

 El conjunto de operaciones y manipulaciones aplicables.
 El espacio de almacenamiento necesario para almacenar dichos valores.
 La interpretación del valor almacenado.

Por ejemplo, al especificar que un dato es de tipo double estamos indicando que se trata de un
número real, representado internamente en punto flotante con doble precisión (normalmente usando 8
bytes) y que se puede manipular con los operadores predefinidos +, -, * y /.

Los tipos se pueden clasificar en simples y compuestos. Los tipos simples se caracterizan porque sus
valores son indivisibles, es decir, no se dispone de operadores para acceder a parte de ellos. Por ejemplo,
si 126.48 es un valor de tipo double, podemos usar el operador + para sumarlo con otro, pero no
disponemos de operadores predefinidos para acceder a sus dígitos individualmente (aunque esto se
pueda realizar indirectamente mediante operaciones de bits o aritméticas). Por el contrario, los tipos
compuestos están formados como un agregado o composición de otros tipos, ya sean simples o
compuestos.

5.1.1. Tipos Simples Predefinidos

El lenguaje de programación C++ proporciona los siguientes tipos simples predefinidos:

int float double bool char

El tipo int se utiliza para trabajar con números enteros. Su representación suele coincidir con la
definida por el tamaño de palabra del procesador sobre el que va a ser ejecutado, hoy día suele ser de 4
bytes (32 bits), aunque en determinados ordenadores puede ser de 8 bytes (64 bits). Puede ser
modificado para representar un rango de valores menor, mediante el modificador short (normalmente 2
bytes [16 bits]) o para representar un rango de valores mayor, mediante el modificador long
(normalmente 4 bytes [32 bits] u 8 bytes [64 bits]) y long long (normalmente 8 bytes [64 bits]). También
puede ser modificado para representar solamente números naturales (enteros positivos) utilizando el
modificador unsigned.

Tanto el tipo float como el double se utilizan para representar números reales en formato de punto
flotante. Se diferencian en el rango de valores que se utiliza para su representación interna. El tipo
double (“doble precisión”) se suele representar utilizando 8 bytes ([64 bits]), mientras que el tipo float
(“simple precisión”) se suele representar utilizando 4 bytes [32 bits]). El tipo doublé también puede ser
modificado con long para representar “cuádruple precisión” (normalmente 12 bytes [96 bits]).

El tipo bool se utiliza para representar valores lógicos (o booleanos), es decir, los valores
“Verdadero” o “Falso” o las constantes lógicas true y false. Suele almacenarse en el tamaño de palabra
más pequeño posible direccionable (normalmente 1 byte).

El tipo char se utiliza para representar caracteres, es decir, símbolos alfanuméricos (dígitos y letras
mayúsculas y minúsculas), de puntuación, espacios, control, etc. Normalmente utiliza un espacio de
almacenamiento de 1 byte (8 bits) y puede representar 256 valores diferentes.

Todos los tipos simples tienen la propiedad de ser indivisibles y además, mantener una relación de
orden entre sus elementos. Se les conoce también como tipos escalares. Todos ellos, salvo los de punto
flotante (float y double), tienen también la propiedad de que cada posible valor tiene un único antecesor
y un único sucesor.

A éstos se les conoce como tipos ordinales (en terminología C++, también se les conoce como tipos
integrales, o enteros). La siguiente tabla muestra las características fundamentales de los tipos simples
predefinidos.

5.1.2. Tipos Simples Enumerados

En ocasiones el programador puede estar interesado en trabajar con tipos simples cuyos valore no
coinciden con las características de ninguno de los tipos simples predefinidos. Entonces puede definir un
nuevo tipo enumerado, cuyos valores serán aquellos que explícitamente se enumeren. De esta forma se
consigue disponer tipos que expresan mejor las características de las entidades manipuladas por el
programa, por lo que el programa será más legible y fácil de entender.

Por ejemplo, si en un programa quisiéramos tratar con colores, con lo visto hasta ahora, para hacer
referencia a un determinado color habría que seleccionar un tipo predefinido (por ejemplo, char) y
suponer que cada color será representado por un cierto carácter (por ejemplo, ’A’ para el color azul). En
su lugar, podemos definir un nuevo tipo Color que contenga AZUL como uno de sus valores
predefinidos. Para ello, haríamos lo siguiente:

enum Color {
ROJO,
AZUL,
AMARILLO
} ;
 En realidad, internamente cada valor de la enumeración se corresponde con un valor natural, siendo
el primero el cero e incrementándose de uno en uno. En nuestro ejemplo ROJO se corresponde
internamente con 0, AZUL con 1, etc. Los tipos enumerados, al ser tipos definidos por el programador,
no tiene entrada ni salida predefinida por el lenguaje, sino que deberá ser el programador el que
especifique (programe) cómo se realizará la entrada y salida de datos en caso de ser necesaria.

6. Entrada y Salida de Datos Básica

El lenguaje de programación C++ depende principalmente de dos comandos que van a permitir la
entrada y salida de datos durante todo el proceso. El primero de ellos es conocido como “cin” que es el
flujo de entrada asociado al teclado. La entrada de datos permite recibir información desde el exterior,
esta se realiza (desde el teclado) mediante el operador >> sobre el flujo “cin” especificando la variable
donde almacenar el valor de entrada leído desde el teclado.

La salida de datos permite mostrar información al exterior, y se realiza a través de los flujos de
salida. El flujo de salida asociado a la salida estándar (usualmente la pantalla o terminal de la consola) se
denomina “cout”. La salida de datos a pantalla se realiza utilizando el operador << sobre el flujo “cout”
especificando el dato cuyo valor se mostrará. Existe otro comando, que, aunque a lo largo de este trabajo
casi no se utiliza, es necesario nombrarlo, “cerr”, que es el flujo de error estándar asociado a la pantalla.

Los operadores << y >> son operadores de inserción y extracción de flujo respectivamente, y no
deben confundirse con los de desplazamiento de bits. Estos operadores son muy eficaces porque no es
necesario especificar formatos para presentación o lectura, ellos los presentan en función al tipo de datos
de la variable. Aunque en ocasiones podría necesitar de la ayuda del operador para obtener los
resultados específicos.

7. Estructuras de Control
7.1.Sentencia, Secuencia y Bloque

En C++ la unidad fundamental de acción es la sentencia, y se expresa la composición de sentencias

como una secuencia de sentencias terminadas por el carácter “punto y coma” (;). Su orden de ejecución
(flujo de ejecución) es secuencial, es decir, cada sentencia se ejecuta cuando termina la anterior,
siguiendo el orden en el que están escritas en el texto del programa. Un bloque es una unidad de
ejecución mayor que la sentencia, y permite agrupar una secuencia de sentencias como una unidad.

7.2.Declaraciones Globales y Locales

El uso de los bloques introduce a la posibilidad de declarar identificadores en diferentes bloques,

pudiendo entrar en conflicto unos con otros, por lo que debemos conocer las reglas utilizadas en el
lenguaje C++ para decidir a qué identificador se refiere en cada caso. Distinguiremos dos clases de
declaraciones: Globales y Locales

 Entidades globales son aquellas que han sido definidas fuera de cualquier bloque. Su ámbito de
visibilidad comprende desde el punto en el que se definen hasta el final del fichero.
 Entidades locales son aquellas que se definen dentro de un bloque. Su ámbito de visibilidad
comprende desde el punto en el que se definen hasta el final de dicho bloque. Este tipo de entidades
se crean en el punto donde se realiza la definición, y se destruyen al finalizar el bloque.
7.3.Sentencias de Selección

Para poder describir el comportamiento de las variables es necesario el uso las sentencias de
selección, que permitan efectuar preguntas y seleccionar el comportamiento adecuado en función del
resultado de las mismas. Están divididas en:

 Secuencia if
 Secuencia switch
7.4.Sentencias de Iteración. Bucles

Las sentencias de iteración se utilizan para repetir la ejecución de un determinado grupo de sentencias
dependiendo de condiciones establecidas. El flujo de ejecución estará iterando (por eso se les conoce
como bucles), repitiendo la ejecución del grupo de sentencias (cuerpo del bucle) hasta que lo determine
la expresión lógica utilizada para decidir la finalización del bucle. Comprende las siguientes sentencias:

 Sentencia while
 Sentencia for
 Sentencia do-while
 7.5.Programación Estructurada

Un programa sigue una metodología de programación estructurada si todas las estructuras de control que
se utilizan (secuencia, selección, iteración y modularización) tienen un único punto de entrada y un
único punto de salida. Esta característica hace posible que se pueda aplicar la abstracción para su diseño
y desarrollo. La abstracción se basa en la identificación de los elementos a un determinado nivel,
ignorando los detalles especificados en niveles inferiores.

8. Subprogramas. Funciones y Procedimientos.

El diseño de un programa es una tarea compleja, por lo que debe ser abordarla siguiendo un enfoque
que permita hacerla lo más simple posible. Al igual que ocurre en otros contextos, la herramienta
fundamental para abordar la solución de problemas complejos es la abstracción: una herramienta mental
que nos permite tratar el problema identificando sus elementos fundamentales y dejando para más
adelante el estudio de los detalles secundarios. La aplicación de este principio al desarrollo de programas
permite seguir un enfoque de refinamientos sucesivos: en cada fase del diseño del programa ignoramos
los detalles secundarios y nos centramos en lo que nos interesa en ese momento; en fases posteriores
abordamos los detalles que hemos ignorado por el momento.

De esta forma, al final se tiene un diseño completo, obtenido con menor esfuerzo y de forma más
segura. Los lenguajes de programación ofrecen la posibilidad de definir subprogramas, permitiendo al
programador aplicar explícitamente la abstracción en el diseño y construcción de software. Un
subprograma puede ser visto como un mini programa encargado de resolver un subproblema, que se
encuentra englobado dentro de otro mayor. En ocasiones también pueden ser vistos como una
ampliación del conjunto de operaciones básicas del lenguaje de programación, proporcionándole nuevas
herramientas no disponibles de forma predefinida.

8.1. Funciones y Procedimientos.

Un subprograma codifica la solución algorítmica a un determinado problema. Cuando en un

determinado momento de la computación es necesario resolver dicho problema se hace uso de dicho
subprograma mediante una invocación (llamada) al mismo. Por lo general, la resolución del problema
requerirá proporcionar al subprograma la información necesaria para abordar su solución (de entrada al
subprograma), y es posible que el subprograma responda con algún resultado (de salida del
subprograma). Para ello, un subprograma se comunica con el que lo invoca (llama) mediante
parámetros.

Se pueden distinguir dos tipos de subprogramas:

 Procedimientos: encargados de resolver un problema computacional general. En el siguiente

ejemplo se dispone de dos variables x e y, con determinados valores y se hace una invocación al
procedimiento ordenar para conseguir que, como resultado, el menor de dichos números quede
almacenado en la variable x y el mayor en la variable y como se observa, en este momento no no
preocupa qué hay que hacer para que la ordenación realmente tenga efecto, se ignoran esos detalles.
Suponiendo que el subprograma ordenar se encargará de ello. El lenguaje C++ no dispone del
operador ordenar, por lo que en algún momento del diseño se debe refinar esta solución y
proporcionar una definición para dicho subprograma.

int main()
{
int x = 8 ;
int y = 4 ;
ordenar(x, y) ;
cout << x << " " << y << endl ;
}

Como se observa, la función main se comunica con el subprograma ordenar mediante una llamada.
En esta comunicación hay un intercambio de información entre main y ordenar a travé de los parámetros
utilizados en la llamada, en este caso las variables x e y.

 Funciones: encargadas de realizar un cálculo computacional y generar un único resultado. Las

funciones responden a los mismos principios que los procedimientos, salvo que están
especializados para que la comunicación entre el que hace la invocación y la función llamada tenga
lugar de una forma especial, que se adapta muy bien y es muy útil en numerosas situaciones. En el
siguiente ejemplo, la función calcular_menor recibe dos números como parámetros y calcula el
menor de ellos. En este caso la comunicación entre el que hace la llamada (la función main) y la
función llamada se hace de forma diferente. Antes hicimos la invocación en una instrucción
independiente, sin embargo, ahora se hace como parte de una instrucción más compleja. Ello es así
porque una función devuelve un valor (en este caso el menor número) y dicho valor deberá ser
 utilizado como parte de un cálculo más complejo. En el ejemplo, como resultado de la invocación
se obtiene un número que será almacenado en una variable de la función main.

En los ejemplos planteados se observa que tanto procedimientos como funciones se utilizan para
realizar un cálculo, ignorando los detalles y, por tanto, simplificando el diseño del programa
principal. En ambos casos hay una invocación al subprograma correspondiente y un intercambio de
información entre el que llama y el subprograma llamado. La única diferencia entre ambos tipos de
subprogramas está en la forma de hacer las llamadas:

 La llamada a un procedimiento constituye por sí sola una sentencia independiente que puede
ser utilizada como tal en el cuerpo de otros subprogramas (y del programa principal). La
única forma de intercambiar información es a través de los parámetros usados en la llamada.
 La llamada a una función no constituye por sí sola una sentencia, por lo que debe aparecer
dentro de alguna sentencia que utilice el valor resultado de la función. La información se
intercambia a través de los parámetros y mediante el valor devuelto por la función.

8.2. Definición de Subprogramas

Si se intentara compilar los programas utilizados anteriormente como ejemplo, comprobaríamos que
el compilador informa de un mensaje de error. Ello es así porque no sabe a qué se refiere al hacer uso de
ordenar y de calcular_menor. Se trata de dos identificadores nuevos, que no se encuentran predefinidos
en C++ y que, por lo tanto, deben ser declarados antes de su uso, como ocurre con cualquier
identificador nuevo. Nótese que ambos nombres de subprogramas corresponden a tareas que el
programador supone, pero cuya solución no ha sido descrita aún en ninguna parte del programa. Por este
motivo, es necesario proporcionar una definición precisa de los subprogramas ordenar y calcular_menor
que, además, debe estar situada en un punto del programa que la haga visible en el punto en que se usen.
 Un subprograma es como un mini programa encargado de resolver un subproblema, por lo que la
definición de un subprograma no difiere de la definición ya utilizada de la función main, que en realidad
no es más que una función especial. A continuación se muestra un programa completo con la definición
de la función main, que define el comportamiento del programa principal, y las definiciones de los dos
subprogramas ordenar y calcular_menor, utilizados desde la función main.

La definición de un subprograma consta de un encabezamiento y de un cuerpo. En el encabezamiento

se especifica su nombre, su tipo y los parámetros con los que dicho subprograma se comunican con el
exterior. En el cuerpo se describe la secuencia de acciones necesarias para conseguir realizar la tarea que
tiene asignada. El encabezamiento comienza con el nombre del tipo devuelto por el subprograma. Dicho
tipo será void si se trata de un procedimiento, ya que en dicho tipo de subprogramas no se devuelve
ningún valor. Si se trata de una función, dicho tipo será el correspondiente al valor devuelto por la
misma.
 La definición de un subprograma se hace de forma independiente de las llamadas en las que se haga
uso del mismo. Por este motivo, debe contener la declaración de todos los elementos que use. En el caso
de los parámetros, habrá que especificar el nombre con el que nos referimos a ellos en el cuerpo del
subprograma y su tipo.

El cuerpo del subprograma especifica la secuencia de acciones a ejecutar necesarias para resolver el
subproblema especificado, y podrá definir tantas variables locales como necesite para desempeñar su
misión. En el caso de una función, el valor que devuelve (el valor que toma tras la llamada) vendrá dado
por el resultado de evaluar la expresión de la sentencia return. Aunque C++ es más flexible, nosotros
sólo permitiremos una única utilización de la sentencia return y deberá ser al final del cuerpo de la
función. Así mismo, un procedimiento no tendrá ninguna sentencia return en su cuerpo.

8.3.Ejecución de Subprogramas

Cuando se produce una llamada (invocación) a un subprograma:

 Se establecen las vías de comunicación entre los algoritmos llamante y llamado por medio de los
parámetros.
 Posteriormente, el flujo de ejecución pasa a la primera sentencia del cuerpo del subprograma
llamado, cuyas instrucciones son ejecutadas secuencialmente, en el orden en que están escritas.
 Cuando sea necesario, se crean las variables locales especificadas en el cuerpo del subprograma.
 Cuando finaliza la ejecución del subprograma, las variables locales y los parámetros previamente
creados se destruyen, el flujo de ejecución retorna al (sub)programa llamante, y continúa la
ejecución por la sentencia siguiente a la llamada realizada.
9. Arrays y Cadenas

Cuando se declara una variable se está apartando en memoria espacio para guardar sus posibles
valores dependiendo del tipo de dato que se trata. Un array o arreglo son una serie de localidades en
memoria consecutivas que están asignadas a un solo nombre y un mismo tipo de datos.
 9.1. Declaración

La forma de declarar un arreglo de cualquier tipo de datos es la siguiente:

tipo nombre [tamaño] ;

Por ejemplo, puede declararse un arreglo de enteros con 12 elementos.

int MiArreglo [12] ;

El compilador se encargará de asignar la memoria requerida para almacenar determinados valores.

Cuando se declara un arreglo de caracteres se trata entonces de una cadena.

char nombre[20] ;

9.2. Asignación de Valores

Al momento de declarar un arreglo de cualquier tipo, puede inicializarse con los valores que queramos.
Para inicializar un arreglo de enteros:

int MiArreglo[5] ={2,34,78,1,9};

Así, estos valores estarán almacenados en cada elemento del array. Es muy importante hacer
notar que el primer elemento de un arreglo es el elemento 0, entonces, MiArreglo[0] contendrá el
número 2, el segundo ( MiArreglo[1] ) contendrá el número 34 y así sucesivamente hasta MiArreglo[4]
que es el último elemento del array. Si un arreglo cuenta con menos inicalizadores que elementos
entonces el resto se inicializará a 0.n Y en caso de que se trate de una cadena de caracteres puede
realizarse de 2 formas:

char MiCadena[13]= “hola a todos”;

o bien, declarar cada elemento

char MiArray[5]={'h','o','l','a','\0'};

Cuando se inicializa una cadena por el primer método, automáticamente se coloca un carácter de
terminación de cadena (el carácter \0), en cambio, de la segunda forma debe colocarse manualmente.
También se puede excluir el tamaño del arreglo, el compilador lo determinará en la compilación.

Para acceder a cada elemento del arreglo se debe especificar su posición (la primera es la
posición 0). En tiempo de ejecución puede asignarse valores a cada elemento cuidando siempre de no
sobrepasar el tamaño del arreglo, si se sobrepasa ese tamaño se escribirán datos en un área de la
memoria que no está asignada para ese array, y puede escribir datos en un área en donde se almacenaba
otra variable del programa o un componente del sistema, esto ocasionaría resultados no deseados. El
siguiente programa es una muestra del uso de arreglos de caracteres.

¿Qué hace este programa?, sencillamente puede afirmarse que almacena una cadena introducida
por el usuario, para luego modificar cada carácter por medio de un ciclo hasta que encuentre el carácter
de terminación (\0) o llegue al limite de caracteres. Quizá no parezca muy interesante este ejemplo, pero
hay que recordar que con cosas pequeñas se construyen grandes cosas, adornando un poco el programa,
se puede suponer que la cadena que introduce el usuario es un mensaje que debe ser secreto, en lugar de
sumar 5 a cada carácter se le puede sumar el número que quiera el usuario. El mismo programa pero un
poco “adornado” o “presuntuoso” queda de la siguiente forma:
 La manipulación
de cadenas es uno de los
temas más extensos en
cuestiones de
programación y de los más importantes. Desde las acciones más básicas como la concatenación de
cadenas, la ordenación y búsqueda en arreglos, hasta los complicados algoritmos de criptografía o la
búsqueda a velocidades increíbles.

10. Estructuras de Entrada y Salida por Archivos en C++

Cuando se hace referencia a entrada/salida estándar (E/S estándar) expresa que los datos o bien se
están leyendo del teclado, ó bien se están escribiendo en el monitor de video. Como se utilizan muy
frecuentemente se consideran como los dispositivos de E/S por default y no necesitan ser nombrados en
las instrucciones de E/S. En el lenguaje C++ se tienen varias alternativas para ingresar y/o mostrar datos,
dependiendo de la librería que se necesite utilizar para desarrollar el programa, entre estas están:
iostream.h y sodio.h.

10.1. Iostream.H

Las operaciones de entrada y salida no forman parte del conjunto de sentencias de C++, sino que
pertenecen al conjunto de funciones y clases de la biblioteca estándar de C++. Ellas se incluyen en los
archivos de cabecera iostream.h por lo que siempre se quieran utilizar, se debera introducir la línea de
código #include <iostream.h>

Esta biblioteca es una implementación orientada a objetos y está basada en el concepto de flujos. A
nivel abstracto un flujo es un medio de describir la secuencia de datos de una fuente a un destino o
sumidero. Así, por ejemplo, cuando se introducen caracteres desde el teclado, se puede pensar en
caracteres que fluyen o se trasladan desde el teclado a las estructuras de datos del programa. Los objetos
de flujo que vienen predefinidos serán:

 cin, que toma caracteres de la entrada estándar (teclado)

 cout, pone caracteres en la salida estándar (pantalla)
 cerr y clog ponen mensajes de error en la salida estándar.

Estos objetos se utilizan mediante los operadores << y >>. El operador “<<”, se denomina operador
de inserción; y apunta al objeto donde tiene que enviar la información. Por lo tanto la sintaxis de cout
será:

cout<<variable1<<variable2<<...<<variablen;

Nota: las cadenas de texto son variables y se ponen entre “ ” (comillas dobles). Por su parte “>>” se
denomina operador de extracción, lee información del flujo cin (a la izquierda del operador) y las
almacena en las variables indicadas a la derecha). La sintaxis sería la siguiente:

cin>>variable1>>...>>variablen;

Que mostraría por pantalla la frase "Introduce un número" y posteriormente almacenaría el valor
introducido por teclado en la variable i.

10.2. Operaciones de Salida.

 Printf: Imprimir en pantalla. Para utilizar la función printf en nuestros programas debemos
incluir la directiva:

#include <stdio.h>

Si sólo se quiere imprimir una cadena basta con escribir la siguiente línea de código.

printf( "Cadena" );

Como resultado muestra en pantalla:

Cadena
Lo que se coloque entre las comillas es lo que saldra por pantalla. Si se volviera a usar otro printf, por
ejemplo:

#include <stdio.h>
void main()
{
printf( "Cadena" );
printf( "Segunda" );
}

Se obtendrá: Cadena Segunda

Este ejemplo muestra cómo funciona printf. Para escribir en la pantalla se usa un cursor que no
vemos. Cuando se escribe algo el cursor va al final del texto. Cuando el texto llega al final de la fila,
lo siguiente que se ponga irá a la fila siguiente. Si lo que se quiere es sacar cada una en una línea
deberemos usar "\n". Es el indicador de retorno de carro. Lo que hace es saltar el cursor de escritura
a la línea siguiente:

#include <stdio.h>
void main()
{
printf( "Cadena\n" );
printf( "Segunda" );
}

y se obtendrá: Cadena Segunda. También se puede colocar mas de una cadena dentro del printf:

printf( "Primera cadena" "Segunda cadena" );.

Lo que no se puede hacer es meter cosas entre las cadenas:

printf( "Primera cadena" texto en medio "Segunda cadena" );

Esto no es válido. Cuando el compilador intenta interpretar esta sentencia se encuentra "Primera cadena"
y luego texto en medio, no sabe qué hacer con ello y da un error.

10.3. Operaciones de Entrada

Algo muy usual en un programa es esperar que el usuario introduzca datos por el teclado. Para ello
contamos con varias posibilidades: Usar las funciones de la biblioteca estándar, crear nuestras propias
interrupciones de teclado (MS-Dos) o usar funciones de alguna biblioteca diferente (como por ejemplo
Allegro). Las funciones estándar están bien para un programa sencillito. Pero cuando se quieren hacer
juegos por ejemplo, no suelen ser suficiente. Demasiado lentas o no dan todas las posibilidades que se
buscan, como comprobar si hay varias teclas pulsadas. Para solucionar esto se tienen dos posibilidades:

La más complicada es crear nuestras propias interrupciones de teclado. ¿Qué es una interrupción de
teclado? Es un pequeño programa en memoria que se ejecuta continuamente y comprueba el estado del
teclado. Se puede crear uno propio y hacer que el ordenador use el que se ha creado en vez del suyo.

Otra posibilidad más sencilla es usar una biblioteca que tenga funciones para controlar el teclado.
Por ejemplo si se usa la biblioteca Allegro, ella misma hace todo el trabajo y el usuario no tiene más que
recoger sus frutos con un par de sencillas instrucciones. Esto soluciona mucho el trabajo y libra de tener
que aprender cómo funcionan los aspectos más oscuros del control del teclado.

 Scanf: El uso de scanf es muy similar al de printf con una diferencia, nos da la posibilidad de
que el usuario introduzca datos en vez de mostrarlos. No nos permite mostrar texto en la
pantalla, por eso si queremos mostrar un mensaje usamos un printf delante. Un ejemplo:

#include <stdio.h>
void main()
{
int num;
printf( "Introduce un número " );
scanf( "%i", &num );
printf( "Has tecleado el número %i\n", num );
}

Primero es necesario observar unas notas de estética, para hacer los programas un poco más
elegantes. Parece una tontería, pero los pequeños detalles hacen que un programa gane mucho. El scanf
no mueve el cursor de su posición actual, así que en nuestro ejemplo queda:

Introduce un número _ /*

La barra horizontal indica dónde está el cursor */. Esto es porque en el printf no se ha puesto al
final el símbolo de salto de línea '\n'. Además se ha dejado un espacio al final de “Introduce un número:”
para que así cuando se teclee el número no salga pegado al mensaje. Si no se hubiese dejado el espacio
quedaría así al introducir el número 120 (es un ejemplo): Introduce un número120

Posteriormente así se puede visualizar cómo funciona el scanf. Lo primero en lo que hay que
fijarse es que hay una cadena entre comillas. Esta es similar a la de printf, la cual sirve para indicarle al
compilador qué tipo de datos estamos pidiendo. Como en este caso es un integer se usa “%i!. Después
de la coma se tiene la variable donde se almacena el dato, en este caso 'num'. En el scanf la variable
'num' lleva delante el símbolo “&”, este es muy importante, y sirve para indicar al compilador cual es la
dirección (o posición en la memoria) de la variable. C++ ofrece una alternativa a las llamadas de funcion
printf y scanf para manejar la entrada/salida de los tipos y cadenas de datos estandar. Así en lugar de
printf se utiliza el flujo estandar de salida cout y el operador << ("colocar en"); y en lugar de scanf
usamos el flujo de entrada estandar cin y el operador >> ("obtener de"). Estos operadores de inserción y
extracción de flujo, a diferencia de printf y scanf, no requieren de cadenas de formato y de formato y de
especificadotes de conversión para indicar los tipos de datosque son extraidos o introducidos.

11. Ejemplo.

Elabore un programa que lea el valor del radio y calcule la longitud de la circunferencia, el área del
círculo y el volumen de la esfera correspondiente a ese radio. Realice el diagrama de flujo y la corrida en
frío.

Longitud de la circunferencia = 2πr Area de la circunferencia= πr^2

Volumen de la esfera= 4/3 πr^3

#include <iostream> #include <cmath>

#include <iomanip>

using namespace std;

int main(void)
{

const float PI = 3.1416;

float radio;
cout << “Introduce el valor del radio :”;
cin >> radio;
 cout << “\nLongitud de la circunferencia:” << fixed << setprecision(2)
<<2*PI*radio;
cout << “\nArea del circulo:”<< PI*pow(radio,2);
cout << “\nVolumen de la esfera:”<< (4.0/3)*PI*pow(radio,3) << endl;
system(“pause”);

Secuencia Acción (Instrucción) Valor de:

C R A L V
1 Pi = 3,1416 3,1416 ? ? ? ?
Inicio de la Iteración 1
2 Escribir ( “Introduce el valor del radio” ) 3,1416 ? ? ? ?
3 Leer ( radio ) 3,1416 5 ? ? ?
Se establecen dos decimales de precisión para
los cálculos correspondientes
4 Calcular ( “Longitud de la circunferencia” ) 3,1416 5 ? 31,41 ?
5 Escribir ( “Valor de la longitud” ) 3,1416 5 ? 31,41 ?
6 Calcular ( “Área del circulo” ) 3,1416 5 78,54 ? ?
7 Escribir ( “Valor del área” ) 3,1416 5 78,54 ? ?
8 Calcular ( “Volumen de la esfera” ) 3,1416 5 ? ? 523,59
9 Escribir ( “Valor del volumen” ) 3,1416 5 ? ? 523,59
Fin de la Iteración 1

Leyenda:
C: Constante L: Longitud
R: Radio V: Volumen
A: Area

A
Inicio

V <- 4/3*Pi*radio^3
Pi

‘Volumen’

radio

L <- 2*PI*radio
Fin

‘Longitud’
 A <- PI*radio^2

‘Area’

A Conclusión

El lenguaje de programación C++ ha sido uno de los lenguajes que más uso se le ha dado con el
pasar de los años gracias a la flexibilidad que este ofrece a sus usuarios, todo esto a pesar de que en el
mercado existen nuevos lenguajes en apariencia más novedosos y con capacidades más interesantes para
los desarrolladores de aplicaciones y programas. La característica principal por la cual este leguaje se ha
mantenido vigente por tanto tiempo es por su potencia, y porque brinda una forma de realizar las tareas
bastante cómoda, lo cual es especialmente útil para programadores que en algún momento desarrollaron
un código usando otro de los lenguajes disponibles hoy en día, específicamente el lenguaje C , ya que les
permite ir entrando y familiarizándose de a poco con el C++, combinando las instrucciones y códigos de
los dos lenguajes, a la vez que se utiliza en compilador característico de C++.
 Bibliografía

Deitel, Harvey M.; Deitel, Paul J. C++, cómo programar. Editorial Pearson Educación. 4ª ed., 2003.
1320 pp

Sánchez, Jorge. Java 2. www.jorgesanchez.net. 2004, 312pp.

Schildt, Herbert. C, Manual de referencia. Editorial Osborne McGraw-Hill. 4ª ed., 2000. 709 pp.

Sierra Urrecho, Alejandro; Alfonseca Moreno, Manuel. Programación en C/C++. Editorial Anaya
Multimedia. Madrid, España, 1999. 351 pp.

Stevens, Al; Walnum, Clayton. Programación con C++. Editorial Anaya Multimedia. Madrid, España,
2000. 832 pp.