Introducción a la Programación en C++ · 2020. 8. 6. · 1 | Introducción a C++ El lenguaje C++...

Introducción a laProgramación en C++

Con ejemplos e ilustraciones

Primera Edición

Semestre 2020A - EPN

Índice general

1. Introducción a C++ 11.1. Qué es programar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11.2. Lenguaje de programación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21.3. Qué es un IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

1.3.1. CodeBlocks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31.3.2. Geany . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3.3. Dev C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.3.4. OnlineGBD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4

1.4. Instrucciones básicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41.5. Mi primer programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

1.5.1. Estructura del código fuente . . . . . . . . . . . . . . . . . . . . . . . . . . 51.6. Comentarios en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61.7. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

1.7.1. Tipos de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81.8. Entrada y salida de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.9. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

1.9.1. Operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101.9.2. Operadores de asignación . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

1.10. Constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.11. Conversión de tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2. Sentencias condicionales y repetitivas 152.1. Expresiones lógicas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

2.1.1. Expresiones lógicas compuestas . . . . . . . . . . . . . . . . . . . . . . . . 152.2. Sentencias condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

2.2.1. Sentencia if-else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162.2.2. Sentencia switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

2.3. Sentencias repetitivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.3.1. Sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.3.2. Sentencia do - while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.3.3. Sentencia for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.4. Ámbito de las variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

3. Datos estructurados 273.1. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.1.1. Inicialización de vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.2. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.2.1. Inicialización de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.3. Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.4. Estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

3.4.1. Estructuras Anidadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

2

4. Números aleatorios 364.1. Generación de números aleatorios enteros . . . . . . . . . . . . . . . . . . . . . . 364.2. Generación de números aleatorios decimales . . . . . . . . . . . . . . . . . . . . . 384.3. Evaluación de integrales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

5. Funciones 425.1. Definición de función . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425.2. Parámetros por defecto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 445.3. Tipos de datos que devuelve una función . . . . . . . . . . . . . . . . . . . . . . . 455.4. Funciones void . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465.5. Almacenamiento de variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

5.5.1. La Pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485.5.2. Estado de la pila . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5.6. Funciones recursivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505.7. Paso por variable o referencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

5.7.1. Referencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515.7.2. Paso por referencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53

5.8. Paso de parámetros tipo estructura . . . . . . . . . . . . . . . . . . . . . . . . . . 565.9. Sobrecarga de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 575.10. Paso de parámetros de tipo vector . . . . . . . . . . . . . . . . . . . . . . . . . . 585.11. Paso de parámetros de tipo array . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6. Punteros 636.1. Qué es un puntero ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 636.2. Puntero nulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.3. Parámetros por referencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 646.4. Aritmética de punteros y vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

7. Librería STL 707.1. Vectores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

7.1.1. Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 727.2. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74

8. Clases y Objetos 778.1. Definición de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 788.2. Uso de clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798.3. Constructores y destructores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 798.4. Sobrecarga de operadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 828.5. Sobrecarga de los operadores de entrada y salida . . . . . . . . . . . . . . . . . . 838.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

1 | Introducción a C++

El lenguaje C++ (se lee C plus plus) fue creado a mediados de los años 80 y es uno de loslenguajes de programación más utilizados. De hecho muchos de los programas que utilizamosdiariamente están hechos en lenguaje C++, por ejemplo: los sistemas operativos Windows, Linuxy macOS, los programas de Office, el sistema Android, entre muchos otros.

1.1. Qué es programarProgramar es decirle al ordenador lo que tiene que realizar. Como el ordenador no es una per-sona, sino una máquina, éste no va entender lo que tiene que hacer si no le indicamos de unamanera que pueda entenderlo.

Como ejemplo nos vamos a ubicar sobre un auto de Fórmula 1, si deseamos que el auto acelereesto se lo diremos presionando el acelerador, o si deseamos que disminuya la velocidad esto selo diremos presionando el freno.

Figura 1.1: Auto Fórmula 1

Si deseamos realizar un giro a la derecha o izquierda, esto se lo diremos girando el volante.En resumen, el auto hará en todo momento lo que le digamos que haga, es decir, seguirá lasinstrucciones que le demos mediante las acciones que le indiquemos para ello.

Con los ordenadores sucede lo mismo. Harán lo que les hayamos dicho que hagan. Las instruc-ciones que damos al ordenador, se pueden dar directamente, en su propio lenguaje, o puedenestar ya integradas en un paquete que instalemos.

Figura 1.2: Word & Winedt

1

CAPÍTULO 1. INTRODUCCIÓN A C++ 2

De modo general, programar consiste en dar una serie de instrucciones a la máquina para queesta se comporte de una determinada manera. Estas instrucciones se guardan dentro de un pro-grama informático o aplicación.

Como los programas pueden guardarse en la memoria del ordenador, el usuario, cada vez quequiera realizar una tarea que ya está definida en un programa, sólo tiene que abrirlo y ejecutar.

1.2. Lenguaje de programaciónLos lenguajes de programación indican al ordenador qué es lo que este tiene que hacer. Para ellotenemos dos códigos:

El código fuente: El lenguaje (líneas de texto) en el que el programador escribe lasórdenes que debe ejecutar el ordenador.

El código máquina: El lenguaje (señales eléctricas almacenadas como unos y ceros) queentiende el ordenador, y en el cual debe recibir las órdenes para ejecutarlas.

Figura 1.3: Diferencias en entre el código fuente y código máquina

Estos dos lenguajes no son iguales, por lo que necesitamos un instrumento que pueda traducirel código fuente a código máquina, si queremos que el ordenador entienda lo que le decimos enel código fuente. Este instrumento es el compilador.

Figura 1.4: Compilador

Por otra parte, el programador necesita una aplicación en donde poder escribir el código fuente.


1.3. Qué es un IDE

Un IDE, llamado también Entorno de Desarrollo Integrado (IDE son sus siglas en inglés), esun programa o aplicación que consiste en un entorno de trabajo para programar. La aplicacióntiene varias herramientas útiles para el programador, entre ellas:

1. Menú de opciones: Permite crear, guardar, modificar, ejecutar proyectos y archivos.

2. Editor: Permite ingresar el código fuente.

3. Visualización documentos: Ventana en la cual se muestran los archivos sobre los cuales seestán trabajando. Permite identificar la jerarquía de los archivos.

4. Compilador y depurador: A partir del archivo en código fuente, crea un archivo en códigomáquina, además, se indican los errores que tiene el código.

Figura 1.5: Ejemplo de IDE

1.3.1. CodeBlocks

Es una de las principales aplicaciones de Entorno de Desarrollo Integrado para C++. Para sudescarga ingresamos a su sitio oficial: http://www.codeblocks.org/downloads/26.

Figura 1.6: Logo CodeBlocks

Allí tenemos varias opciones para descargar la aplicación. Dependiendo del sistema operativoque disponga el ordenador, iremos a la sección de Windows, Linux 32, Linux 64, o Mac OS X.

http://www.codeblocks.org/downloads/26.


1.3.2. Geany

Es una aplicación de Entorno de Desarrollo Integrado que se adapta bastante bien a la pro-gramación con C++. Para su descarga ingresamos a su sitio oficial: http://www.geany.org/Download/Releases

Figura 1.7: Logo Geany

1.3.3. Dev C++

Es una aplicación de Entorno de Desarrollo Integrado que se puede usar para programar conC++. Para su descarga iremos a su sitio oficial: http://www.bloodshed.net/dev/devcpp.html

Figura 1.8: Logo Dev C++

La instalación de los IDEs se realiza todo por defecto (a todo le damos siguiente).

1.3.4. OnlineGBD

Es una aplicación online muy utilizada en la actualidad que permite correr códigos en C++,Java, Phyton, entre otros.

Se puede acceder a la aplicación desde el enlace: https://www.onlinegdb.com

Figura 1.9: Logo OnlineGBD

1.4. Instrucciones básicasEl funcionamiento básico para cualquiera de las IDEs antes comentadas es el siguiente:

1. Abrimos la aplicación y creamos un nuevo archivo (proyecto), o abrimos uno ya existentepara modificarlo. Este archivo será el archivo fuente, y su contenido el código fuente.

2. Escribimos las instrucciones en lenguaje C++ (es decir, el código fuente), en el espacio deedición de la aplicación.

http://www.geany.org/Download/Releases

http://www.geany.org/Download/Releases

http://www.bloodshed.net/dev/devcpp.html

https://www.onlinegdb.com


3. Compilamos y ejecutamos. La compilación crea un nuevo archivo (o sustituye al ya exis-tente). Este nuevo archivo es el archivo ejecutable, y su contenido está escrito en códigomáquina. Al ejecutarlo, éste se abre y se realizan las instrucciones que contiene.

A partir de aquí daremos ya por hecho que sabemos hacer estos pasos, tanto de apertura dearchivos, como de compilar y ejecutar, y nos centraremos más en el propio lenguaje C++.

1.5. Mi primer programaEn la gran mayoría de los IDEs al momento de crear un nuevo archivo nos encontraremos conel siguiente código:

1 # include <iostream >2 using namespace std;34 int main () {5 cout << "Hola Mundo " << endl;6 return 0;7 }

En los siguientes enlaces se comenta a mayor detalle el primer programa en C++:

⋄ http://y2u.be/ld4nzao5XAc

⋄ http://y2u.be/ZJIP_cO6JwM

1.5.1. Estructura del código fuente

Ahora vamos a analizar con detalle las líneas del código anterior:

include <iostream>Esta línea inicia con almohadilla # y encarga al preprocesador que se incluya una secciónde código C++ estándar (bibliotecas o librerías) que permite realizar operaciones de en-trada y salida de datos.

Para entender de mejor manera la necesidad de emplear bibliotecas usaremos la siguientemetáfora:

Imaginemos que tener instalado el programa en el computador es como haber adquiridoun auto nuevo el cual cumple con ciertas funciones principales y no trae contratiempos,una vez que lo empezamos a rodar nos vamos dando cuenta de la necesidad de mejorar elrendimiento de ciertos mecanismos ya existentes del auto debido que lo vamos exponien-do a diferentes ambientes y condiciones. Lo anterior pasa exactamente con C++, cuandodescargamos e instalamos el software contamos con ciertas características y funcionalida-des básicas pero existen varias bibliotecas adicionales que pueden ser agregadas para lograrmejorar su funcionalidad y a la vez realizar cosas estupendas.

En el siguiente enlace se enlistan las principales bibliotecas o librerías:

⋄ http://www.cplusplus.com/reference/

http://y2u.be/ld4nzao5XAc

http://y2u.be/ZJIP_cO6JwM

http://www.cplusplus.com/reference/


using namespace std;Esta línea declara un namespace o espacio de nombres. En concreto el namespace std oestándar. Dentro del namespace std están declarados todos los elementos de las bibliotecasestándar.Mediante esta línea podemos usar los elementos de la biblioteca estándar sin necesidad detener que declararlos cada vez que se usan.

Si no se utiliza la instrucción using namespace std, entonces los nombres cout y endl delcódigo anterior se deberían escribir como std::cout y std::endl.

int main( )Esta estructura es la función principal que contiene el código. Lo que se escriba dentro delas llaves de esta función es el código fuente en sí, es decir el programa que se ejecutará.

La primera palabra int, nos dice el tipo del valor de retorno de la función, en este casoun número entero. La función main siempre devuelve un entero. La segunda palabra es elnombre de la función, en general será el nombre que se usa para realizar el llamado a lafunción.

cout << Hola Mundo << endl;Esta sentencia tiene varias partes: En primer lugar cout, que identifica el dispositivo desalida de caracteres estándar (por lo general, la pantalla del ordenador).

En segundo lugar, el operador de inserción (<<), que indica que lo que sigue debe inser-tarse (mostrarse en pantalla).

Por último, una frase entre comillas (Hola Mundo), que es el contenido insertado.

Estas dos últimas partes se repiten para volver a insertar otro elemento, es decir repetimosel operador de inserción (<<) y luego indicamos lo que debe insertarse, en este caso es unsalto de línea que se indica mediante la instrucción endl.

return 0;La palabra return es reservada propia de C++. Indica al programa que debe abandonar laejecución de la función y continuar a partir del punto en que se la llamó. El 0 es el valor deretorno de nuestra función. Cuando main retorna el valor 0 indica que todo ha marchadobien.

Cada instrucción en el programa debe terminar con un ";".

1.6. Comentarios en C++Un comentario es un texto que sirve para que el programador pueda documentar su código. Loscomentarios no son analizados por el compilador. Existen dos tipos de comentarios:

Comentario en bloque: Texto encerrado entre /* y */, puede ocupar más de una línea.No se pueden anidar, es decir, no se puede colocar un comentario dentro de otro.


Comentario de línea: Texto que inicia con //. Una vez escritos estos dos caracteres loque queda de línea se considera un comentario.

1 # include <iostream >2 using namespace std;34 int main () {5 // Este es un comentario en linea6 cout << "Mi segundo programa en C++" << endl;7 /*8 Este es un comentario en bloque9 !!!

10 */1112 return 0;13 }

1.7. Variables

Lo contrario de una salida de datos (mensajes en pantalla) es una entrada de datos. En la entradade datos el usuario escribe un dato por teclado, y éste dato es recogido por el ordenador.

Figura 1.10: Esquema variable

Sin embargo, para poder recoger los datos necesitamos antes tener un recipiente en donde guar-darlo, y éste será la variable. A continuación, se muestra un programa que emplea variables paraalmacenar un texto y un número.

1 # include <iostream >2 using namespace std;34 int main (){5 // Definimos las variables ...6 string frase = " Codigo Internacional Telefonico para Ecuador ";7 int numero = 593;89 // Salida en pantalla de las variables ...

10 cout << frase << " : " << numero << endl;1112 return 0;13 }

Una variable es una parte de la memoria del ordenador en donde se almacena un dato.


Cada variable necesita un nombre que la identifique, y que la diferencie de las demás. Adicio-nalmente, en C++ debemos indicar el tipo de dato que queremos almacenar (número, cadenade letras, etc.).

Al dato que se almacena en la variable se le llama valor. Podemos cambiar el valor (el dato quese almacena) de una variable, siempre que sea del tipo indicado.

1.7.1. Tipos de variables

Existen varios tipos de variables, y cada uno corresponde a un tamaño máximo de un número,un carácter o cadena de caracteres. Cuanto mayor sea el número que pueda admitir, más espacioen memoria ocupará. Los principales tipos de variables se enlistan a continuación:

1. bool: Las variables de este tipo sólo pueden tomar dos valores true o false. Sirven paraevaluar expresiones lógicas.Por lo general utiliza 1 byte de memoria, valores: true o false.

2. char: Es el tipo básico alfanumérico, es decir que puede contener un carácter, un dígitonumérico o un signo de puntuación.Utiliza generalmente 1 byte de memoria, permite almacenar un carácter, valores; 256caracteres.

3. unsigned short int: Las variables enteras almacenan números enteros dentro de los límitesde su tamaño, a su vez, ese tamaño depende de la plataforma del compilador, y del númerode bits que use por palabra de memoriaUtiliza generalmente 2 bytes de memoria, valores: de 0 a 65535.

4. unsigned long int:Utiliza generalmente 4 bytes de memoria, valores: de 0 a 4294967295.

5. int:Utiliza generalmente 4 bytes de memoria, valores: de -2147483648 a 2147483647.

6. float: Las variables de este tipo almacenan números en formato de coma flotante y expo-nente, para entendernos, son números con decimales.Utiliza generalmente 4 bytes de memoria, valores: de 1,2 × 10−38 a 3,4 × 10+38.

7. double: Las variables de este tipo almacenan números en formato de coma flotante yexponente, al igual que float, pero usan mayor precisión.Utiliza generalmente 8 bytes de memoria, valores: de 2,3 × 10−308 a 1,8 × 10+308.

A continuación, un programa que muestra algunos límites numéricos:

1 # include <iostream >2 # include <limits >3 using namespace std;45 int main () {6 cout << " Maximo entero :" << numeric_limits <int >:: max () << endl;7 cout << " Minimo entero :" << numeric_limits <int >:: min () << endl;8 cout << " Maximo float :" << numeric_limits <float >:: max () << endl;9 cout << " Minimo float :" << numeric_limits <float >:: min () << endl;

10


11 return 0;12 }

En el siguiente enlace se muestran todos los tipos de variables que admite C++:

⋄ http://www.cplusplus.com/doc/tutorial/variables/

1.8. Entrada y salida de datosEn C++ se puede enviar información a la salida estándar, que como se explicó previamente estáconectada por defecto al monitor o pantalla, mediante la instrucción cout. La sintaxis básica esla siguiente:

1 cout << expresion 1 << expresion 2 << ... << endl;

La instrucción anterior se encarga de convertir el resultado de cada expresión en una cadena decaracteres y de enviar dicha cadena a la salida estándar.

Para la lectura de datos se emplea la instrucción cin. La sintaxis básica es la siguiente:1 cin >> variable 1 >> variable 2 >> ... >> variable n;

donde: variable 1, variable 2 y variable n son variables. Esta instrucción provoca la lectura dedatos desde la entrada estándar, que por defecto está asociada al teclado, y su almacenamientoen las variables especificadas en la instrucción.

Los nombres de las instrucciones anteriores provienen de Character OUTput y Character INput.

A continuación, un programa que muestra la entrada y salida de datos:1 # include <iostream >2 using namespace std;34 int main () {5 // Definimos dos variables a y b del tipo double6 double a;7 double b;8 // Se imprime un mensaje al usuario9 cout << " Ingrese dos numeros " << endl;

10 // Se leen dos numeros ingresados a traves del teclado11 cin >> a;12 cin >> b;13 // Se imprime un mensaje y la suma de los dos numeros14 cout << "La suma de los numeros ingresados es:" << a+b << endl;1516 return 0;17 }

1.9. OperadoresLos operadores son elementos que disparan ciertos cálculos cuando son aplicados a variables uotros objetos en una expresión. Primero revisemos algunas definiciones importantes:

http://www.cplusplus.com/doc/tutorial/variables/


Operando: cada una de las cantidades, constantes o variables o expresiones que intervie-nen en una expresión.

Expresión: según el diccionario, “Conjunto de términos que representan una cantidad”,entre nosotros es cualquier conjunto de operadores y operandos, que dan como resultadouna cantidad.

Existe una división en los operadores atendiendo al número de operandos que afectan (unitarios,binarios o ternarios).

1.9.1. Operadores aritméticos

Son usados para crear expresiones matemáticas. Existen dos operadores aritméticos unitarios +y - que tienen la siguiente sintaxis:

+ <expresión>- <expresión>

Asignan valores positivos o negativos a la expresión a la que se aplican.1 # include <iostream >2 using namespace std;34 int main (){5 int a=5;6 cout << " Numero positivo : " << +a << endl;7 cout << " Numero negativo : " << -a << endl;89 return 0;

10 }

En cuanto a los operadores binarios existen varios: ’+’, ’-’, ’*’ y ’/’, tienen un comportamientoanálogo, ya que admiten variables enteras y de coma flotante.

<expresión> + <expresión><expresión> - <expresión><expresión> * <expresión><expresión> / <expresión>

Evidentemente se trata de las conocidísimas operaciones aritméticas de suma, resta, multiplica-ción y división.

1 # include <iostream >2 using namespace std;34 int main (){5 int a,b;6 cout << " Ingrese dos numeros enteros positivos : " << endl;7 cin >> a >> b;8 // Empleamos operadores binarios9 cout << "Suma : " << a + b << endl;

10 cout << " Resta : " << a - b << endl;11 cout << " Multiplicacion : " << a * b << endl;12 cout << " Division : " << a / b << endl;1314 return 0;15 }


El operador de módulo %, devuelve el resto de la división entera del primer operando entre elsegundo. Por esta razón, no puede ser aplicado a operandos en coma flotante.

<expresión> % <expresión>

Otras operaciones como la potencia y radicación se encuentran definidas dentro de la biblio-teca cmath, por lo cual, para utilizar dichas operaciones se debe incluir la siguiente sentencia:#include <cmath>.

Función Descripciónsqrt(x) Raíz cuadradaexp(x) Potencia eulerianalog(x) Logaritmo neperiano

log10(x) Logaritmo en base 10ceil(x) Redondea al entero superior más próximofloor(x) Redondea al entero inferior más cercanofabs(x) Valor absolutocos(x) Cosenosin(x) Senotan(x) Tangente

Cuadro 1.1: Algunas funciones de la biblioteca cmath

A continuación, un programa que realiza las operaciones de potencia y radicación:

1 # include <iostream >2 # include <cmath >3 using namespace std;45 int main (){6 int a;7 cout << " Ingrese un numero positivo " << endl;8 cin >> a;9

10 cout << "La raiz cuadrada es : " << sqrt(a) << endl;11 cout << "El cubo del numero es: " << pow(a ,3) << endl;12 cout << " Logaritmo neperiano : " << log(a) << endl;13 cout << "El resto de dividir para 2 es : " << a %2 << endl;1415 return 0;16 }

Por último, otros dos operadores unitarios un tanto especiales, ya que sólo pueden trabajar sobrevariables, pues realizan una asignación (semiautomática). Se trata de los operadores ’++’y ’- -’.El primero de ellos incrementa el valor del operando y el segundo lo decrementa, ambos en unaunidad.

<variable> ++ (post-incremento)++ <variable> (pre-incremento)<variable>-- (post-decremento)-- <variable> (pre-decremento)

A continuación, un programa que facilita el entendimiento de los operadores de incremento ydecremento:


1 # include <iostream >2 using namespace std;34 int main (){5 int a=1, b=2, c=3;6 cout << "a++ : " << a++ << endl;7 cout << "++b * 2 : " << ++b * 2 << endl;8 cout << "a : " << a << " y b : " << b << endl;9 cout << "b-- : " << b-- << endl;

10 cout << "++c * 3: " << ++c * 3 << endl;11 cout << "c++ : " << c++ << endl;12 cout << "a++ + --b + c-- : " << a++ + --b + c-- << endl;1314 return 0;15 }

1.9.2. Operadores de asignación

Existen varios operadores de asignación, el más evidente y el más usado es el =, pero no es elúnico. El operador de asignación se utiliza para asignar un valor a una variable. Su sintaxis esla siguiente:

<variable> <operador de asignación> <expresión>

Si se desea escribir una expresión como a = a+8, en la que se incrementa el valor de una va-riable en una cantidad, entonces se puede utilizar el operador += de la siguiente forma: a += 8.Esta última expresión incrementa la variable que aparece a la izquierda del operador += en unacantidad dada.

A continuación, un programa que emplea varios operadores de asignación:

1 # include <iostream >2 using namespace std;34 int main () {5 int a, b, c;6 cout << " Ingrese tres numeros " << endl;7 cin >> a >> b >> c;8 a += 8;9 cout << "El primer numero incrementado en 8 unidades : " <<

10 a << endl;11 b *= 3;12 cout << "El triple del segundo numero es : " << b << endl;13 c *= c;14 cout << "El cuadrado del tercer numero es : " << c << endl;1516 return 0;17 }

Los operadores -=, *=, /= y %= tienen un comportamiento análogo a += pero aplicados a la resta,multiplicación, división y módulo, respectivamente.


Forma larga Forma cortaa = a + b; a += b;a = a - b; a -= b;a = a * b; a *= b;a = a / b; a /= b;a = a % b; a %= b;

Cuadro 1.2: Operadores de asignación

En los siguientes enlaces se muestran otros ejemplos sobre operadores:

⋄ http://y2u.be/dKNZKgsv9og

⋄ http://y2u.be/Y0n-P5qZ1d0

⋄ http://y2u.be/nrmfgM5t2go

⋄ http://y2u.be/D_QLgW0KnmI

1.10. ConstantesUna constante es una variable que almacena un valor que no varía a lo largo de la ejecuciónde un programa. En C++ se puede definir una constante anteponiendo al tipo de variable lapalabra reservada const.

Por convención, los nombres de las constantes se escriben en mayúsculas y se ubican en lasprimeras líneas del código.

A continuación, un programa que emplea constantes:

1 # include <iostream >2 using namespace std;34 int main () {5 const double IVA = 0.12;6 const double PROPINA = 0.05;7 double precio ;8 cout << " Ingrese el valor del consumo " << endl;9 cin >> precio ;

10 precio11 cout << "Su factura con IVA es de : " << precio + precio * IVA12 << " dolares " << endl;13 cout << "Su factura incluida la propina es de : "14 << precio + precio * (IVA + PROPINA ) << " dolares "15 << endl;16 cout << " Gracias por su consumo " << endl;1718 return 0;19 }

http://y2u.be/dKNZKgsv9og

http://y2u.be/Y0n-P5qZ1d0

http://y2u.be/nrmfgM5t2go

http://y2u.be/D_QLgW0KnmI


1.11. Conversión de tiposCuando se realizan operaciones aritméticas con operandos de distinto tipo, C++ realiza unaconversión implícita del operando cuyo tipo tiene un rango de representación menor al tipo deloperando cuyo rango de representación es mayor; de esta forma se puede realizar la operación.

En el caso de una operación entre un número entero y un número real el entero se convierteimplícitamente a real, realizándose la operación entre reales.

A continuación, un programa que ejemplifica la conversión de tipos:

1 # include <iostream >2 using namespace std;34 int main () {5 int a = 32,6 double b = 10.5;7 // Suma de entero y real8 cout << a + b << endl:9 // Division de entero a entero

10 cout << a/5 << endl;11 // Division entero a real12 cout << a/5.0 << endl:13 // Conversion explicita14 cout << ( float ) a/5 << endl;1516 return 0;17 }

En la línea 14 se utiliza el operador de conversión explícita de tipos. Éste es un operador unitariocuya sintaxis es:

(tipo) operando

El efecto del operador es convertir el operando al tipo tipo.

2 | Sentencias condicionales y repe-titivas

2.1. Expresiones lógicasUna expresión lógica es aquella que produce un resultado de verdadero o falso. Se puede construiruna expresión lógica simple utilizando un literal de tipo lógico, es decir, true o false, o combi-nado dos expresiones aritméticas mediante un operador relacional. Los principales operadoresrelacionales de C++ son:

Operador Significado< menor que> mayor que<= menor o igual que>= mayor o igual que== igual que!= distinto de

A continuación, un programa que verifica si los dos números enteros ingresados por el usuarioson iguales:

1 # include <iostream >2 using namespace std;34 int main (){5 int a, b;6 bool res;7 cout << " Ingrese dos numeros enteros " << endl;8 cin >> a >> b;9

10 // Expresion logica simple11 res = a == b;12 cout << " Resultado : " << res << endl;1314 return 0;15 }

2.1.1. Expresiones lógicas compuestas

Una expresión lógica compuesta es aquella formada por expresiones lógicas combinadas medianteoperadores lógicos. Los principales operadores lógicos de C++ son:

15

CAPÍTULO 2. SENTENCIAS CONDICIONALES Y REPETITIVAS 16

Operador Significado&& conjunción|| disyunción! negación

Una expresión lógica compuesta puede contener operadores aritméticos, relacionales y lógicos.

Se recomienda emplear paréntesis en las expresiones lógicas compuestas, con el fin de separar eidentificar cada una de las expresiones lógicas simples.

A continuación, un programa que verifica si los dos números ingresados por el usuario son igualesy pares a la vez:

1 # include <iostream >2 using namespace std;34 int main (){5 int a, b;6 bool res;7 cout << " Ingrese dos numeros enteros " << endl;8 cin >> a >> b;9

10 // Expresion logica compuesta11 res = (a == b) && (a %2 == 0);12 cout << " Resultado : " << res << endl;1314 return 0;15 }

En los siguientes enlaces se presentan a mayor detalle los operadores lógicos y relacionales:

http://y2u.be/7rnxBgZsWQ0

http://y2u.be/MUznvpgtn9g

2.2. Sentencias condicionalesLas sentencias condicionales permiten seleccionar qué codigo ejecutar en función del resultadode evaluar ciertas expresiones lógicas.

2.2.1. Sentencia if-else

La sentencia if-else permite ejecutar un código de manera condicional en función del resultadode evaluar una condición lógica. Su sintaxis es la siguiente:

if(expresión lógica){bloque de instrucciones 1

} else {bloque de instrucciones 2

}

http://y2u.be/7rnxBgZsWQ0

http://y2u.be/MUznvpgtn9g


Figura 2.1: Flujograma sentencia if - else

La sentencia if-else primero evalúa la expresión lógica (condición). Si la expresión es verdadera,entonces se ejecuta el bloque de instrucciones 1, en caso de ser falsa se ejecuta el bloque deinstrucciones 2.

Sobre la sintaxis de la sentencia if-else se debe tener en cuenta lo siguiente:

La expresión lógica debe aparecer encerrada entre paréntesis.

Los bloques de instrucciones se encierran entre llaves.

La parte else es opcional.

Se recomienda escribir los bloques de instrucciones un poco a la derecha (con sangrado oindentados), pues esto aumenta la legibilidad del programa.

A continuación, un ejemplo que permite identificar si el número entero ingresado por el usuarioes par o impar:

1 # include <iostream >2 using namespace std;34 int main (){5 int a;6 cout << " Ingrese un numero entero " << endl;7 cin >> a;89 // Sentencia condicional

10 if ((a % 2) == 0){11 cout << "El numero ingresado es par" << endl;12 } else {13 cout << "El numero ingresado es impar " << endl;14 }15 return 0;16 }

Las raíces reales de un polinomio de segundo grado de la forma: ax2 + bx + c = 0, pueden serobtenidas mediante la expresión:

x1,2 = −b ±√

b2 − 4ac

2a

a continuación, se presenta un programa que permite obtener dichas raíces en el caso que existan.


1 # include <iostream >2 # include <cmath >3 using namespace std;45 int main (){6 double a, b, c, d;7 cout << " Raices del polinomio : ax ^2 + bx + c = 0" << endl;8 cout << " Ingrese los coeficientes : " << endl;9 cin >> a >> b >> c;

1011 // Calculo del discriminante12 d = pow(b ,2) - 4*a*c;1314 // Sentencia condicional15 if(d < 0){16 cout << "El polinomio no tiene raices reales " << endl;17 } else if(d == 0) {18 cout << "Las raices son iguales a : "19 << ( float ) -b/(2*a) << endl;20 } else {21 cout << "La primera raiz es : "22 << ( float ) (-b-pow(d ,0.5))/(2* a) << endl;23 cout << "La segunda raiz es : "24 << ( float ) (-b+pow(d ,0.5))/(2* a) << endl;25 }26 return 0;27 }

2.2.2. Sentencia switch

La sentencia switch permite realizar una selección múltiple.

Figura 2.2: Flujograma sentencia switch

La sintaxis de la sentencia switch es la siguiente:


switch (expresion){case literal1:

bloque de instrucciones 1break;

case literal2:bloque de instrucciones 2break;

......case literaln:

bloque de instrucciones nbreak;

default:bloque de instrucciones por defectobreak;

}

La sentencia switch primero evalúa la expresión, misma que aparece en el paréntesis. La expresióndebe producir un resultado de tipo entero, caractér o lógico. A continuación, se compara elresultado de evaluar la expresión con los literales que aparecen en los casos.

1 # include <iostream >2 using namespace std;34 int main (){5 cout << " Ingrese la opcion a ejecutar : " << endl;6 char opcion ;7 cin >> opcion ;89 switch ( opcion ){

10 case ’a’:11 cout << "Ha seleccionado la opcion a" << endl;12 break ;13 case ’b’:14 cout << "Ha seleccionado la opcion b" << endl;15 break ;16 case ’c’:17 cout << "Ha seleccionado la opcion c" << endl;18 break ;19 default :20 cout << "Ha ingresado una opcion incorrecta " << endl;21 }2223 return 0;24 }

Si el resultado de evaluar la expresión coincide con el literal de algún caso, entonces se ejecutael conjunto de instrucciones asociado al caso y el conjunto de instrucciones asociadas al resto decasos que aparecen con posterioridad hasta que se ejecuta la instrucción break que provoca quese salga de la ejecución de la instrucción switch.

A continuación, se presenta un programa que convierte centímetros a pulgadas y libras a kilo-gramos:


1 # include <iostream >2 using namespace std;34 int main () {5 int x;6 float pulgadas , kilo , distancia , peso;7 cout << "Que desea convertir , distancia o peso?" << endl;8 cout << " Escriba 1 para distancia o 2 para peso" << endl;9 cin >> x;

1011 switch (x){12 case 1:13 cout << " Ingrese la distancia en centimetros : " << endl;14 cin >> distancia ;15 pulgadas = distancia / 2.54;16 cout << "Las pulgadas son: " << pulgadas << endl;17 break ;18 case 2:19 cout << " Ingrese el peso en libras : " << endl;20 cin >> peso;21 kilo = peso * (1 / 2.21);22 cout << "Los kilogramos son: " << kilo << endl;23 break ;24 default :25 cout << " Opcion no valida " << endl;26 }2728 return 0;29 }

2.3. Sentencias repetitivasLas sentencias repetitivas o iterativas, también llamadas ciclos o bucles, permiten ejecutar unconjunto de instrucciones de manera reiterada mientras que se verifique una condición lógica.

2.3.1. Sentencia while

La sentencia while permite ejecutar un bloque de instrucciones mientras la expresión lógica seaverdadera.

Figura 2.3: Flujograma sentencia while


La sintaxis es la siguiente:

while(expresión lógica){bloque de instrucciones

}

En primer lugar, se evalúa la expresión lógica. Si el resultado de la evaluación es el valor falso, en-tonces termina la ejecución de la instrucción while. Si el resultado de la evaluación es verdadero,entonces se ejecuta el conjunto de instrucciones asociado a la instrucción while. Una vez ejecu-tado el conjunto de instrucciones se vuelve a evaluar la expresión lógica y se procede como antes.

A continuación, un programa que solicita un número mayor a 10 para finalizar el proceso:

1 # include <iostream >2 using namespace std;34 int main () {5 int numero ;6 cout << " Ingrese un numero entero " << endl;7 cin >> numero ;89 // Sentencia repetitiva

10 while ( numero <= 10){11 cout << " Ingrese otro numero :";12 cin >> numero ;13 }14 return 0;15 }

Ahora analicemos un programa que suma todos los números ingresados por el usuario, parafinalizar el proceso es necesario teclear el número 999:

1 # include <iostream >2 using namespace std;34 int main () {5 int num , suma;67 cout << " ------- Programa Suma -------" << endl;8 num = 0;9 suma = 0;

1011 while (num != 999){12 suma += num;13 cout << " Ingresa un numero ( teclea 999 para terminar ): "14 << endl;15 cin >> num;16 }17 cout << "La suma total es: " << suma << endl;1819 return 0;20 }


Finalmente, se muestra un programa que recibe dos números a, x con |x| < 1 y determina elmenor valor de n para el que se cumple la expresión:∣∣∣∣∣ a

1 − x−

n∑i=0

axi

∣∣∣∣∣ < 10−7

1 # include <iostream >2 # include <cmath >3 using namespace std;45 int main () {6 double a, x;7 const double ERROR = pow (10, -7);8 cout << " Ingrese los valores de a y x : " << endl;9 cin >> a >> x;

1011 // Sentencia condicional sobre x12 if(x > -1 && x < 1){13 double sum = 0;14 int i = 0;15 // Sentencia repetitiva para hallar el valor de n16 while (a/(1 -x) - sum > ERROR ){17 sum += a*pow(x,i);18 i++;19 }20 cout << "El valor de n buscado es : " << i-1 << endl;21 } else {22 cout << "El valor de x no es valido " << endl;23 }2425 return 0;26 }

2.3.2. Sentencia do - while

La sentencia do-while es muy parecida a la sentencia while. La principal diferencia con la senten-cia while es que en la sentencia do-while el conjunto de instrucciones se ejecutará por lo menosuna vez.

Figura 2.4: Flujograma sentencia do - while


La sintaxis es la siguiente:do {

bloque de instrucciones} while (expresión lógica);

Una vez ejecutado el conjunto de instrucciones se evalúa la expresión lógica. Si el resultado dela evaluación es verdadero se vuelve a ejecutar el conjunto de instrucciones, así hasta que laexpresión lógica sea falsa, en cuyo momento termina la ejecución de la instrucción.

A continuación, un programa que transforma los grados centígrados a fahrenheit y viceversa:1 # include <iostream >2 using namespace std;34 int main (){5 int opcion ;6 float centi , fahre;7 bool terminar = false ;8 cout << " --- Conversion de temperaturas ---" << endl;9

10 do {11 cout << " Escoja una opcion : " << endl;12 cout << "1. Convertir Grados centigrados a Fahrenheit :"13 << endl;14 cout << "2. Convertir Grados Fahrenheit a Centigrados :"15 << endl;16 cout << "3. Salir del programa " << endl;17 cin >> opcion ;1819 switch ( opcion ){20 case 1:21 cout << " Ingrese los grados centigrados : " << endl;22 cin >> centi;23 fahre = (centi *1.8) + 32;24 cout << "Su equivalente en fahrenheit es: "25 << fahre << endl;26 break ;27 case 2:28 cout << " Ingrese los grados fahrenheit : " << endl;29 cin >> fahre;30 centi = (fahre - 32)/1.8;31 cout << "Su equivalente en centigrados es: "32 << centi << endl;33 break ;34 default :35 cout << " Gracias por usar el programa " << endl;36 terminar = true;37 }38 } while (! terminar );3940 return 0;41 }


2.3.3. Sentencia for

La sentencia for está pensada principalmente para expresar ciclos que se ejecutan un número fijode veces. La sentencia for resulta más legible que las sentencias while y do while, pues permiteexpresar la iniciación, incremento y condición lógica asociada a la variable que controla el cicloen una única línea al principio del ciclo.

Figura 2.5: Flujograma sentencia for

La sintaxis de la instrucción for es la siguiente:

for (inicializacion; expresión lógica; incremento){conjunto de instrucciones

}

El funcionamiento de la instrucción es el siguiente:

Se ejecuta la inicialización del ciclo, esta expresión se ejecuta una única vez.

A continuación se evalúa la expresión lógica. Mientras que el resultado de evaluar la ex-presión lógica sea verdadero se ejecuta el conjunto de instrucciones.

Por último, se realiza el incremento o decremento del contador.

A continuación, un programa que calcula el factorial de un número entero:

1 # include <iostream >2 using namespace std;34 int main () {5 int numero , fact = 1;6 cout << " Introduzca un entero positivo : " << endl;7 cin >> numero ;8 for (int i = 1; i <= numero ; i++){9 fact *= i;

10 }11 cout << "El factorial de " << numero << " es " << fact << endl;12 return 0;13 }

Para finalizar esta sección revisemos un programa que determina si un número entero positivoingresado por el usuario es primo:


1 # include <iostream >2 using namespace std;34 int main (){5 int numero , i;6 bool primo = false ;78 cout << " Ingrese un entero positivo (0 para terminar ): "9 << endl;

10 cin >> numero ;1112 while ( numero != 0){13 for(i = 2; i < numero ; i++){14 if( numero % i == 0)15 primo = true;16 }17 if(primo ){18 cout << "El numero " << numero << " no es primo "19 << endl;20 } else {21 cout << "El numero " << numero << " es primo " << endl;22 }23 cout << " Ingreses un entero positivo (0 para terminar ): ";24 cin >> numero ;25 primo = false ;26 }2728 return 0;29 }

2.4. Ámbito de las variablesC++ proporciona unas reglas muy flexibles para elegir el lugar en el que se define una variable.En función del lugar de su definición, una variable tiene un ámbito, que es la zona del programaen la que puede ser usada. A continuación, se enumeran las principales reglas sobre el lugar dedefinición y ámbito de las variables:

Una variable puede definirse en cualquier lugar en el que se puede escribir una instrucción.El ámbito de la variable abarca desde su lugar de definición hasta el final del bloquemás interno en que se ha definido la variable (un bloque es un conjunto de instruccionesencerradas entre llaves).

Se puede definir una variable en la parte de iniciación de una sentencia for. En ese caso elámbito de la variable es el cuerpo y cabecera de la instrucción for.

Se puede definir más de una vez una misma variable, es decir, con el mismo identifica-dor dentro del cuerpo de una función siempre que las definiciones ocurran en bloques nosolapados o en bloques solapados de distinto nivel de profundidad.

Un código que intenta explicar de mejor modo el ámbito de aplicación de las variables:


1 # include <iostream >2 using namespace std;34 int main (){5 int z=3;6 int x=8;78 if(true ){9 int x = 0;

10 cout << x << endl;11 }1213 for(int x = 1; x < 11; x++){14 cout << x << endl;15 }16 cout << x << endl;1718 if(true ){19 int z=4;20 cout << z << endl;21 }22 cout << z << endl;2324 return 0;25 }

Una aplicación importante del ámbito de las variables se presenta en la sentencia switch, alponer entre llaves los bloques de instrucciones y el break; de cada caso. Al hacer esto si definimosvariables dentro de las llaves solamente serán efectivas para ese caso, pero si no hacemos usode ellas las variables definidas dentro de un caso serán validas para todos los casos dentro de lasentencia switch.

C++ permite la escritura de valores numéricos en notación científica, para ello emplearemos laletra e como potencia 10. Es decir:

3.000.000 = 3.0e6

0.0000567 = 5.67e-5

3 | Datos estructurados

En los primeros capítulos del curso se han estudiado los tipos de datos primitivos de C++, esdecir, los tipos de datos numéricos, lógicos y carácter. Ahora, analizaremos los tipos de datosestructurados, estos se utilizan para almacenar colecciones de datos del mismo tipo o diferentestales como: vectores, estructuras y cadenas de caracteres.

3.1. VectoresUn vector es una estructura unidimensional que almacena una secuencia de datos del mismotipo. Los elementos de un vector se almacenan en zonas contiguas de memoria y se puede accedera ellos de manera directa mediante un índice o posición.

Figura 3.1: Estructura de un vector

Para definir un vector se utiliza la siguiente sintaxis:

tipo nombre[tamaño];

donde tipo es el tipo de los elementos del vector, nombre es el nombre de la variable que sirvepara referenciar al vector y tamaño indica el número de elementos del vector.

En C++ los índices de los vectores empiezan en cero.

El tamaño debe expresarse mediante una expresión constante de tipo entero.

No es válido definir el tamaño de un vector a partir de una variable ingresada por el usuario.

int x; // Variablecout << "Ingrese un entero" << endl;cin >> x;double vector[x]; // No valido

27

CAPÍTULO 3. DATOS ESTRUCTURADOS 28

Para acceder a los elementos de un vector se utiliza la sintaxis:

nombre[posicion];

donde nombre es el nombre de la variable de tipo vector y posicion es una expresión entera queindica el índice del elemento del vector al que se quiere acceder.

La utilidad de los vectores es que permiten crear múltiples datos de un mismo tipo con unaúnica sentencia de definición y una única variable. Además, el acceso a los datos almacenadosen el vector es muy eficiente y sencillo a partir de su posición.

A continuación, un programa que almacena las componentes de dos vectores de R3 y obtiene lasuma vectorial y el producto interno:

1 # include <iostream >2 using namespace std;34 int main (){5 float vector1 [3];6 float vector2 [3];7 float Suma [3];8 float Producto = 0;9 // Datos del primer vector

10 for(int i=0; i <3; i++){11 cout << " Introduce la componente " << i + 112 << " del primer vector : ";13 cin >> vector1 [i];14 }15 // Datos del segundo vector16 for(int i=0; i <3; i++){17 cout << " Introduce la componente " << i + 118 << " del segundo vector : ";19 cin >> vector2 [i];20 }21 // Suma de vectores22 for(int i=0; i <3; i++){23 Suma[i] = vector1 [i] + vector2 [i];24 }25 // Producto interno26 for(int i=0; i <3; i++){27 Producto += vector1 [i] * vector2 [i];28 }29 // Mostramos el resultado30 cout << "El vector suma es ";31 for (int i=0; i <3; i++)32 cout << Suma[i] << " ";33 cout << endl;3435 cout << "El producto interno es: " << Producto << endl;3637 return 0;38 }


3.1.1. Inicialización de vectores

Se puede inicializar un vector en la misma definición de la variable. Para realizar esto hay queencerrar entre llaves la lista de valores con que se inicia el vector, separando los valores entre símediante comas.

A continuación, un programa que obtiene el total de gastos de una familia X:

1 # include <iostream >2 using namespace std;34 int main (){5 int gastos [6] = {200 , 150, 100, 250, 300, 285};6 int suma;78 suma = 0;9 for (int i=0; i <=4; i++){

10 suma += gastos [i];11 };1213 cout << "El gasto total es : " << suma;1415 return 0;16 }

Si inicializamos un vector, no será necesario que indiquemos su tamaño, porque el compiladorlo puede saber contando los valores ingresados en la lista.

1 # include <iostream >2 using namespace std;34 int main (){5 int diasMes [] = {31, 28, 31, 30, 31, 30,6 31, 31, 30, 31, 30, 31};78 string Mes [] = {"Enero ", " Febrero ", " Marzo ", " Abril ", "Mayo",9 " Junio ", " Julio ", " Agosto ", " Septiembre ", " Octubre ",

10 " Noviembre ", " Diciembre "};1112 for(int i=0; i <12; i++){13 cout << "El mes de " << Mes[i] << " tiene " << diasMes [i]14 << " dias" << endl;15 };1617 return 0;18 }

3.2. MatricesUna matriz es una estructura bidimensional que almacena una secuencia de datos del mismo tipoen filas y columnas. Los elementos de una matriz se almacenan en zonas contiguas de memoriay se puede acceder a ellos de manera directa mediante la posición (fila y columna).


Figura 3.2: Estructura de una matriz

La sintaxis para declarar una matriz en C++ es la siguiente:

tipo nombreMatriz[filas][columnas];

donde tipo corresponde al tipo de elementos que se van almacenar, nombreMatriz corresponde alnombre de la estructura matriz, filas y columnas son expresiones enteras que indican el númerode filas y columnas, respectivamente, que tendrá la estructura matriz.

Al igual que en los vectores, los índices de las filas y columnas de una matriz empiezan en cero.

A continuación, un programa que suma dos matrices de orden 2 × 2:

1 # include <iostream >2 using namespace std;34 int main (){5 double matriz1 [2][2];6 double matriz2 [2][2];7 double Suma [2][2];89 // Ingreso valores matriz 1

10 cout << " Matriz 1" << endl;11 for(int i=0; i <2; i++){12 for(int j=0; j <2; j++){13 cout << " Ingrese el elemento " << i+1 << j+1 << " : ";14 cin >> matriz1 [i][j];15 }16 }1718 // Ingreso valores matriz 219 cout << " Matriz 2" << endl;20 for(int i=0; i <2; i++){21 for(int j=0; j <2; j++){22 cout << " Ingrese el elemento " << i+1 << j+1 << " : ";23 cin >> matriz2 [i][j];24 }25 }2627 // Suma de matrices28 for(int i=0; i <2; i++){29 for(int j=0; j <2; j++){30 Suma[i][j] = matriz1 [i][j] + matriz2 [i][j];31 }


32 }3334 // Resultado35 cout << "El resultado es : " << endl;36 for(int i=0; i <2; i++){37 for(int j=0; j <2; j++){38 cout << Suma[i][j] << " ";39 }40 cout << endl;41 }42 return 0;43 }

En cuanto tenemos declarado una matriz, es posible asignarle valores a cada una de sus casillas,evidentemente estos valores deben coincidir con el tipo de dato que le asignamos a dicha matriz.

3.2.1. Inicialización de matrices

Se puede inicializar una matriz en la misma definición de la variable. Para realizar esto hay queencerrar entre llaves la lista de valores de cada fila con que se inicia la matriz, separando losvalores entre sí mediante comas.

A continuación, un programa que almacena la notas del examen de dos grupos de 10 alumnoscada uno y compara el promedio de cada curso:

1 # include <iostream >2 using namespace std;34 int main (){5 int Notas [][10] = {{17 , 20, 13, 14, 15, 19, 17, 18, 19, 10},6 {18, 12, 19, 14, 15, 16, 17, 13, 19, 20 }};78 // Promedio por curso9 double prom1 =0, prom2 =0;

10 for(int i=0; i <10; i++){11 prom1 += 0.1* Notas [0][i];12 prom2 += 0.1* Notas [1][i];13 }1415 // Comparacion promedios16 if(prom1 > prom2 ){17 cout << "El primer curso tiene mejor promedio " << endl;18 } else if(prom1 < prom2 ){19 cout << "El segundo curso tiene mejor promedio " << endl;20 } else {21 cout << "Ambos cursos tienen igual promedio " << endl;22 }2324 return 0;25 }


Es posible inicializar matrices únicamente especificando el número de columnas. Por default, elcompilador analiza la lista de datos y contabiliza el número de filas.

3.3. ArraysC++ permite trabajar con arrays multidimensionales, es decir, de varias dimensiones.

Figura 3.3: Estructura de un array

Para definir un array multidimensional de dimensión n se utiliza la siguiente sintaxis:

tipo nombreArray[tam1][tam2]...[tamn];

donde tipo es el tipo de los elementos del array, nombreArray es el nombre de la variable asocia-da al array y tam1, tam2, . . . , tamn son expresiones constantes de tipo entero que indican lostamaños de las distintas dimensiones del array.

A continuación, un programa que almacena las ventas de 4 tipos de productos de golosinas en3 diferentes ciudades durante 2 días y calcula el total de ventas por producto:

1 # include <iostream >2 using namespace std;34 int main (){5 int Ventas [4][3][2] = {12, 20, 13, 34, 15, 24, 16, 28, 11, 18,6 31, 25, 23, 34, 21, 10, 18, 28, 31, 17,7 15, 19, 28, 34};89 // Vista Array

10 for(int k=0; k <2; k++){11 for(int i=0; i <4; i++){12 for(int j=0; j <3; j++){13 cout << Ventas [i][j][k] << " ";14 }15 cout << endl;16 }17 cout << endl;18 cout << endl;19 };2021 // Total Ventas por producto22 int TPro [4]; // Vector que almacena los totales23 for(int i=0; i <4; i++){24 TPro[i] = 0; // Inicializamos la celda


25 for(int j=0; j <3; j++){26 for(int k=0; k <2; k++){27 TPro[i] += Ventas [i][j][k];28 }29 }30 };3132 // Resultados por producto33 for(int i=0; i <4; i++){34 cout << "Total Producto " << i+1 << " : " << TPro[i] << endl;35 }3637 return 0;38 }

Se debe tener mucho cuidado con el manejo de los índices en los arrays para no confundir lasdimensiones sobre las cuales se pretende trabajar.

3.4. EstructurasC++ permite que el programador defina nuevos tipos de datos. Una forma de hacerlo es me-diante una estructura. Una estructura define un nuevo tipo de dato que está compuesto por unacolección de datos de tipos existentes ya sean tipos básicos o estructurados como arrays, cadenasde caracteres o estructuras ya definidas. Las estructuras son muy útiles pues permiten definirtipos de datos que se ajustan con exactitud a las necesidades de representación de cualquierobjeto. Con una estructura se puede representar un alumno, un seguro, un vehículo, etc.

RojoToyotaModelo 2018230 CV

VerdeFordModelo 2016280 CV

AzulMercedes BenzModelo 2020350 CV

Figura 3.4: Ejemplo de un estructura

La sintaxis de definición de una estructura es:

struct nombre{tipo1 campo1;tipo2 campo2;...tipon campon;

};

La definición de una estructura comienza con la palabra reservada struct, seguida del nombredel nuevo tipo que se está definiendo. A continuación, y encerrados entre llaves, aparecen los


datos que componen el nuevo tipo. A cada uno de los datos se le llama campo o miembro. Ladefinición de cada campo tiene la estructura de la definición de una variable, es decir, en primerlugar se especifica el tipo del campo y a continuación su nombre.

A continuación, un programa que registra la información de 5 individuos definiendo una nuevaestructura y obtiene la edad promedio:

1 # include <iostream >2 using namespace std;34 // Definicion nueva estructura5 struct persona {6 char nombre [15];7 int edad;8 char sexo [15];9 int telefono ;

10 };1112 int main (){13 persona amigo [5];14 // Ingreso de informacion15 for(int i = 0; i < 5; i++){16 cout << " Escriba el Nombre " << i+1 << ":";17 cin >> amigo[i]. nombre ;18 cout << "\ nEscriba la Edad de " << i+1 << ":";19 cin >> amigo[i]. edad;20 cout << "\ nEscriba el sexo " << i+1 << ":";21 cin >> amigo[i]. sexo;22 cout << "\ nEscriba el Telefono de " << i+1 << ":";23 cin >> amigo[i]. telefono ;24 cout <<endl;25 };2627 // Impresion registros28 cout << "El registro de personas que se introdujeron es :\n\n";29 for (int i = 0; i < 5; i++){30 cout << "\t" << amigo[i]. nombre ;31 cout << "\t" << amigo[i]. edad;32 cout << "\t" << amigo[i]. sexo;33 cout << "\t" << amigo[i]. telefono << "\n\n";34 };3536 // Edad promedio37 double EProm = 0;38 for (int i = 0; i < 5; i++){39 EProm += 0.2* amigo[i]. edad;40 };4142 cout << "La edad promedio es : " << EProm << endl;4344 return 0;45 }


3.4.1. Estructuras Anidadas

C++ permite que se incluya un struct dentro de otro, de este modo, podemos encontrarnos conun registro que tenga varios datos, y a su vez ocurra que uno de esos datos se encuentre formadopor varios datos más sencillos.

A continuación, un ejemplo en el que se emplea una estructura anidada:

1 # include <iostream >2 # include <string >3 using namespace std;45 struct FechaNac {6 int anio , mes , dia;7 };89 struct estudiante {

10 string nombre , genero ;11 FechaNac fecha;12 };1314 int main (){15 estudiante E1 = {"Luis", " Masculino " , {1997 , 10, 29}};1617 cout << " Nombre del estudiante : " << E1. nombre << endl;18 cout << " Genero : " << E1. genero << endl;19 cout << " Fecha de nacimiento : " << E1.fecha.dia << "/"20 << E1. fecha.mes << "/" << E1.fecha.anio << endl;21 return 0;22 }

4 | Números aleatorios

Una característica importante en la gran mayoría de lenguajes de programación es la posibilidadde generar números aleatorios.

Los números aleatorios son pieza clave en la programación de juegos de azar, simulaciones,cifrado de datos, en modelos estadísticos, etc. En esta capítulo aprenderemos a generar númerosaleatorios para automatizar el proceso de llenado de arreglos y más.

4.1. Generación de números aleatorios enterosUno de los métodos más comunes para generar números aleatorios, llamado método congruen-cial multiplicativo, comienza con un valor inicial x0, llamado semilla, y luego se calcula demanera recursiva los valores sucesivos xn, n ≥ 1, haciendo:

xn = axn−1 mod m

donde a y m son enteros positivos dados y lo anterior significa que axn−1 se divide entre m y elresiduo se considera como el valor de xn.

Así, cada xn toma valores entre: 0, 1, . . . m − 1 y la expresión xn

m(llamada número pseudoalea-

torio) se considera como una aproximación del valor de una variable aleatoria uniforme en elintervalo (0, 1).

Figura 4.1: Números aleatorios

La generación de números aleatorios en C++ se realiza por medio de la función rand(), mis-ma que se encuentra definida en la librería cstdlib. La función rand() devuelve un númeroentero aleatorio en el rango de 0 a RAND_MAX, donde RAND_MAX es el límite superior y es-te último depende de la capacidad computacional del ordenador, así como del sistema operativo.

A continuación, se muestra un programa que genera y almacena 20 números enteros aleatoriosentre 0 y RAND_MAX:

36

CAPÍTULO 4. NÚMEROS ALEATORIOS 37

1 # include <iostream >2 # include <cstdlib >3 using namespace std;45 int main (){6 int vec [20];78 // Generamos valores entre 0 y RAND_MAX9 for(int i=0; i <20; i++){

10 vec[i] = rand ();11 cout << vec[i] << " ";12 }1314 // Limite superior permitido por el equipo15 cout << "\n El RAND_MAX para este equipo es: " << RAND_MAX ;1617 return 0;18 }

Si ejecutamos varias veces el programa anterior se puede observar que los números obtenidosen cada ejecución coinciden. Esto se debe principalmente a que la semilla es exactamente lamisma en cada ejecución. Para solventar este problema se recomienda resetear la semilla encada llamado del código por medio del siguiente comando:

srand(time(NULL));

donde srand accede al valor de la semilla y time reemplaza el valor de la semilla por la fecha yhora de ejecución.

Siempre que se desee replicar un experimento o análisis lo recomendado es fijar una semilla.

A continuación, un programa que genera 5 números aleatorios enteros distintos en cada ejecución:

1 # include <iostream >2 # include <cstdlib >3 using namespace std;45 int main (){6 int vec [5];78 // Semilla aleatoria9 srand(time(NULL ));

1011 // Generamos valores entre 0 y RAND_MAX12 for(int i=0; i <5; i++){13 vec[i] = rand ();14 cout << vec[i] << " ";15 };1617 return 0;18 }


En ocasiones, se hace necesario generar números aleatorios enteros comprendidos en el rango[0, M ], con M ∈ N. Para ello, definiremos un nuevo límite superior empleado la notación delmódulo ( %):

rand() % (Limite superior + 1)

A continuación, un programa que genera 100 números aleatorios entre [0, 20] y obtiene la sumade dichos números:

1 # include <iostream >2 # include <cstdlib >3 using namespace std;45 int main (){6 int vec [100];78 // Semilla aleatoria9 srand(time(NULL ));

1011 // Valores aleatorios12 cout << "Los valores generados son : " << endl;13 for(int i=0; i <100; i++){14 vec[i] = rand () % 21;15 };1617 // Calculo suma18 int suma = 0;19 for(int i=0; i <100; i++){20 cout << vec[i] << endl;21 suma += vec[i];22 };2324 cout << "La suma de los valores generados : " << endl;25 cout << suma << endl;2627 return 0;28 }

4.2. Generación de números aleatorios decimalesAhora nos centraremos en la generación de números aleatorios decimales, para ello basta recordarque el número pseudoaleatorio yn = xn

mse distribuye uniformemente en el intervalo (0, 1). Es

decir,yn ∼ U [0, 1]

por tanto,b · yn ∼ U [0, b], para b ∈ R+

y además,a + b · yn ∼ U [a, a + b], para a ∈ R y b ∈ R+

A continuación, se muestra un programa que genera 10 números aleatorios con 4 decimales enel intervalo [1, 4].


1 # include <iostream >2 # include <cstdlib >3 using namespace std;45 int main (){6 double vec [10];78 // Semilla aleatoria9 srand(time(NULL ));

1011 // Generamos valores entre 0 y RAND_MAX12 for(int i=0; i <10; i++){13 vec[i] = 1 + ( double ) (rand () % 30001)/10000;14 cout << vec[i] << " ";15 };1617 return 0;18 }

4.3. Evaluación de integrales

Una de las primeras aplicaciones de los números aleatorios fue el cálculo de integrales. Sea g(x)una función y supongamos que queremos calcular θ, donde:

θ =∫ 1

0g(x)dx

Para calcular el valor de θ note que si U está distribuida uniformemente en (0, 1), entoncespodemos expresar θ como:

θ = E[g(U)]

Si U1, U2, . . . , Uk son variables aleatorias independientes y uniformes en (0, 1), esto implica queg(U1), g(U2), . . . , g(Uk) son variables aleatorias independientes e idénticamente distribuidas conmedia θ.

Por lo tanto, por la ley fuerte de los grandes números, se tiene, con probabilidad igual a 1 que:

k∑i=1

g(Ui)k

→ E[g(U)] = θ, cuando k → ∞

De lo anterior, podemos aproximar θ generando un gran número de números aleatorios ui y con-siderando como nuestra aproximación a θ el valor medio de g(ui). Este método de aproximaciónde integrales es conocido como el método de Monte Carlo.

A continuación, se muestra un programa que aproxima la integral:

θ =∫ 1

0

ex − 1e − 1

dx

mediante el método de Monte Carlo.


1 # include <iostream >2 # include <cmath >3 # include <cstdlib >4 using namespace std;56 int main (){7 int k;8 double u, sum =0;9

10 cout << " Ingrese el valor k" << endl;11 cin >> k;1213 // Semilla aleatoria14 srand(time(NULL ));1516 // Calculo de la integral17 for(int i=0; i<k; i++){18 u = ( double ) (1 + rand () % 10000)/10000;19 sum += ( double ) (exp(u) -1)/( exp (1) -1);20 };2122 // Impresion resultado23 cout << " Valor integral : " << ( double ) sum/k << endl;2425 return 0;26 }

Si quisiéramos calcular la integral:

θ =∫ b

ag(x)dx

entonces, al hacer la sustitución:

y = x − a

b − ay dy = dx

b − a

vemos que:

θ =∫ 1

0g (a + [b − a]y) (b − a)dy

=∫ 1

0h(y)dy

donde h(y) = (b − a)g (a + [b − a]y). Así, podemos aproximar θ al generar de manera continuanúmeros aleatorios y luego considerar el valor promedio de h evaluada en estos números aleato-rios.

A continuación, un programa que calcula la integral definida:

θ =∫ 5

2

x

x2 − 1dx

mediante el método de Monte Carlo.


1 # include <iostream >2 # include <cmath >3 # include <cstdlib >4 using namespace std;56 int main (){7 int k, a=2, b=5;8 double u, z, sum =0;9

10 cout << " Ingrese el valor k" << endl;11 cin >> k;1213 // Semilla aleatoria14 srand(time(NULL ));1516 // Calculo integral17 for(int i=0; i<k; i++){18 u = ( double ) (1 + rand () % 10000)/10000;19 z = a + (b-a)*u;20 sum += (b-a)*(( double ) z/( pow(z ,2) -1));21 }2223 // Impresion resultado24 cout << " Valor integral : " << ( double ) sum/k << endl;2526 return 0;27 }

De manera análoga, si queremos el valor de

θ =∫ ∞

0g(x)dx

podríamos aplicar la sustitución

y = 1x + 1

, dy = −dx

(x + 1)2 = −y2dx

para obtener la identidad

θ =∫ 1

0h(y)dy

donde

h(y) =g

(1y − 1

)y2

5 | Funciones

Una función es un fragmento de código que permite ejecutar una serie de instrucciones para-metrizadas. Las funciones son de gran utilidad porque permiten estructurar el código de unprograma. Una función realiza una tarea concreta y puede ser diseñada, implementada y depu-rada de manera independiente al resto del código.

5.1. Definición de funciónLa sintaxis básica para la definición de una función en C++ es la siguiente:

tipo nombre(tipo1 var1, tipo2 var2, ... , tipon, varn){.....bloque de instrucciones.....return expresion;

}

A la primera línea se le llama signatura de la función e incluye el tipo del valor devuelto por lafunción o valor de retorno, el nombre de la función y la lista de parámetros formales de la fun-ción que consiste en un listado de variables separadas por comas y encerradas entre paréntesis.Cada variable de la lista de parámetros formales viene precedida por su tipo, a continuación, ydelimitado por llaves, viene el bloque de instrucciones asociado a la función, también llamadocuerpo de la función.

El efecto de la sentencia return es evaluar su expresión asociada y terminar la ejecución de lafunción devolviendo el resultado de evaluar la expresión. Se permite una expresión de un tipoque admita una conversión implícita al tipo de retorno de la función.

Las funciones devuelven únicamente tipos básicos: int, double, float, string, etc.

A continuación, un programa que recibe el valor de los catetos de un triángulo rectángulo yretorna el valor de la hipotenusa:

1 # include <iostream >2 # include <cmath >3 using namespace std;45 double hipotenusa ( double cateto1 , double cateto2 ){6 return sqrt(pow(cateto1 , 2) + pow(cateto2 , 2));7 };89 int main (){

42

CAPÍTULO 5. FUNCIONES 43

10 double c1 , c2;11 cout << " Ingrese los valores de los catetos : " << endl;12 cin >> c1;13 cin >> c2;14 cout << "La hipotenusa es : " << hipotenusa (c1 , c2) << endl;1516 return 0;17 }

Nótese que la función hipotenusa devuelve únicamente un valor real.

A continuación, un programa que recibe una calificación numérica y devuelve una etiqueta:

Calificación EtiquetaMenor a 5 ReprobadoEntre 5 y 9 AprobadoMayor a 9 Sobresaliente

1 # include <iostream >2 using namespace std;34 string escala ( double n){5 string etiqueta ;6 if(n < 5){7 etiqueta = " Reprobado ";8 } else if(n <= 9){9 etiqueta = " Aprobado ";

10 } else {11 etiqueta = " Sobresaliente ";12 }13 return etiqueta ;14 };1516 int main (){17 double nota;18 cout << " Ingrese la nota obtenida en el examen : " << endl;19 cin >> nota;20 cout << "La escala alcanzada es : " << escala (nota) << endl;2122 return 0;23 }

Nótese ahora que la función escala devuelve únicamente un texto.

Una función puede contener más de una instrucción return, en ese caso la ejecución de la funciónterminará cuando se ejecute por primera vez una instrucción return.

A continuación, se presenta un programa que obtiene el máximo entre dos números que ingresael usuario por pantalla:


1 # include <iostream >2 using namespace std;34 double maximo ( double x , double y){5 if(x>y)6 return x ;7 return y;8 }9

10 int main (){11 double a,b;12 cout << " Ingrese dos números " << endl;13 cin >> a >> b;14 // Se imprime el máximo de los dos numeros15 cout << "El máximo es : " << maximo (a,b) << endl;1617 return 0;18 }

5.2. Parámetros por defectoEl uso de parámetros por defecto es otra característica propia de C++ que no está presente enalgunos lenguajes de programación. Un parámetro por defecto es un parámetro que no tiene porqué ser especificado al invocar a una función. Si en la invocación de la función no se especificaun parámetro por defecto entonces se le asigna un valor por defecto al parámetro.

A continuación, un programa que calcula el logaritmo en diferentes bases (por defecto se mantienela base 2):

1 # include <iostream >2 # include <cmath >3 using namespace std;45 double logn( double valor , double base =2){6 return log( valor )/ log(base );7 }89 int main (){

10 double x, n;11 cout << " Ingrese un valor y la base :" << endl;12 cin >> x >> n;1314 cout << "El logaritmo de " << x << " en base " << n << " es : "15 << logn(x,n) << endl;16 cout << "El logaritmo de " << x << " en base 2 es : "17 << logn(x) << endl;1819 return 0;20 }


5.3. Tipos de datos que devuelve una funciónEn C++, una función puede devolver valores de aquellos tipos de datos para los que la asigna-ción está definida, la asignación a un tipo de dato está definida si es posible asignar valores alas variables de dicho tipo con el operador de asignación (=).

De los tipos de datos que hemos visto los únicos para los que la asignación no está definida sonlos tipos vector y array. Para el resto de tipos: tipos básicos, estructuras y cadenas de caracteresla asignación está definida y, por tanto, una función puede devolver un dato de tipo básico, detipo string o de tipo estructura, pero no puede devolver un vector.

A continuación, un programa que devuelve una estructura:

1 # include <iostream >2 using namespace std;34 // Definimos una nueva estructura que almacena dos valores5 struct ValMM{6 double max , min;7 };89 // Definimos una función que devuelve la estructura anterior

10 ValMM MaxMin ( double x , double y){11 ValMM num;12 if(x > y){13 num.max = x;14 num.min = y;15 } else {16 num.max = y;17 num.min = x;18 }19 return num;20 };2122 int main (){23 double a, b;24 ValMM numeros ;25 cout << " Ingrese dos valores : " << endl;26 cin >> a >> b;2728 // Llamado a la funcion29 numeros = MaxMin (a,b);30 cout << "El valor máximo es : " << numeros .max << endl;31 cout << "El valor mínimo es : " << numeros .min << endl;3233 return 0;34 }


5.4. Funciones voidSe suele utilizar el término función void para designar a una función que no tiene valor de re-torno. Puesto que la sintaxis de C++ obliga a indicar un tipo de retorno, las funciones voidutilizan el tipo especial void como tipo de retorno.

A continuación, el programa de Hola mundo mejorado:

1 # include <iostream >2 using namespace std;34 void saludo (){5 cout << "Hola Mundo \n";6 }78 int main (){9 saludo ();

10 return 0;11 }

Aunque una función no tenga valor de retorno, es decir, aunque sea una función void es posibleutilizar la sentencia return en su cuerpo para terminar la ejecución de la función. En una funciónvoid la sentencia return debe utilizarse sin expresión asociada, es decir:

return ;

Si una función void no utiliza ninguna sentencia return, la ejecución de la función termina cuandose ejecuta la última instrucción de la función

Las funciones void deben invocarse mediante una instrucción que incluya únicamente la llamadaa la función.

A continuación, un programa que calcula una el valor de pi con un error de 0.00001 entre susaproximaciones:

π

4≈

∞∑i=0

(−1)n

2n + 1

1 # include <iostream >2 # include <cmath >3 using namespace std;45 double termino (int n){6 return (float ) pow(-1, n)/(2*n+1);7 }89 void pi (){

10 float error = 0.00001 , suma = 0, xn , xm;11 int i=0;12 do{13 xn = termino (i);14 xm = termino (i+1);


15 suma += xn;16 i++;17 } while (abs(xn -xm)>= error );1819 cout << " Valor aproximado de pi es : " << 4* suma << endl;20 cout << " Numero de iteraciones : " << i << endl;2122 return ;23 }2425 int main (){26 cout << " Aproximacion de pi\n" << endl;2728 // Llamado a la funcion void29 pi ();3031 return 0;32 }

5.5. Almacenamiento de variablesA las variables definidas en una función se les llama variables locales, en contraste con las varia-bles definidas fuera de las funciones que son llamadas variables globales.

El ámbito de una variable global abarca desde el lugar de su definición hasta el final del ficheroen que se ha definido, pudiendo ser utilizada en cualquier función situada en dicho ámbito.

Una variable local con el mismo nombre que una variable global oculta a la variable global.

A continuación, un programa en el que una variable local oculta a la variable global:

1 # include <iostream >2 using namespace std;34 int fun(int anio ){5 // Variable local anio6 anio = 2019;78 return anio;9 }

1011 int main (){12 // Variable global anio13 int anio = 2000;14 cout << "Nos encontramos en el anio " << fun(anio) << endl;15 cout << "Naci en el anio " << anio << endl;1617 return 0;18 }


El ámbito de una variable local abarca desde su lugar de definición en la función hasta el finaldel bloque más interno en que ha sido definida. Los parámetros formales de una función sonvariables locales de la función y, a efecto de ámbito, se encuentran definidas en el bloque másexterno de la función, es decir, entre las llaves que delimitan el cuerpo de la función.

El uso de variables globales para implementar la comunicación entre funciones presenta algunosinconvenientes:

1. Una función que se comunica con el resto mediante variables globales no es reutilizable,salvo en un entorno en el que se utilicen las mismas variables globales. Se dice que lafunción está fuertemente acoplada al resto del código.

2. El uso de variables globales puede producir los llamados efectos colaterales. Esto ocurrecuando una variable global es ocultada por una variable local inadvertidamente.

Las variables globales se almacenan en una zona de memoria denominada memoria global. Unavariable global permanece almacenada en la memoria global durante todo el tiempo que dure laejecución de un programa lo cual no es óptimo ya que delimita los recursos disponibles.

5.5.1. La Pila

La pila es una zona de memoria contigua donde se almacenan las variables locales de las funcionesy alguna otra información, como la dirección de memoria de retorno de una función. El tamañode la pila varía dinámicamente durante la ejecución de un programa; cuando se invoca a unafunción la pila crece hacia direcciones superiores de memoria para albergar a sus variables locales,se dice que las variables se apilan; cuando una función termina la pila decrece y sus variableslocales dejan de ser accesibles, se dice que las variables se desapilan.

Figura 5.1: Esquema de una pila

Una variable almacenada en la pila tiene un tiempo de existencia limitado al tiempo en que seejecuta el código asociado al ámbito de la variable.

El abuso en la utilización de variables puede acarrear problemas en el rendimiento del computador(tiempo de ejecución) por el excesivo espacio de memoria empleado.

5.5.2. Estado de la pila

Para analizar el estado de una pila durante algunos instantes de una ejecución se analizará elsiguiente programa:


1 # include <iostream >2 using namespace std;34 double maximo ( double x , double y){5 double m;6 if(x>y){7 m = x;8 } else {9 m = y;

10 }11 return m;12 }1314 int main (){15 double a,b;16 cout << " Ingrese dos números " << endl;17 cin >> a >> b;1819 // Se imprime el máximo de los dos numeros20 cout << "El máximo es : " << maximo (a, b) << endl;2122 // Se vuelve a invocar a maximo23 cout << "El máximo de a y 10 es : " << maximo (a, 10) << endl;24 a = 8;25 double z = 3 + maximo (a, a -1);26 cout << "z vale : " << z << endl;2728 return 0;29 }

Ejecutamos el programa anterior considerando a = 6 y b = 8.

Figura 5.2: Estado de la pila durante la ejecución del programa


5.6. Funciones recursivasSe dice que una función es recursiva cuando dentro de su bloque de sentencias hay una llamadaa la propia función.

En principio cualquier función puede hacerse una llamada a sí misma, sin embargo, tiene queestar especialmente diseñada para que funcione correctamente, ya que al llamarse a sí mismaprovoca que ésta se vuelva a ejecutar, y dentro de sus instrucciones se vuelve a llamar, creandoun bucle que si no está controlado se vuelve infinito.

Por lo tanto, una función recursiva forma un bucle al ser llamada a si misma. Este bucle debeser controlado de alguna manera para poder salir de él y no caer en estructuras indeseadas comobucles infinitos o estructuras que se autorreplican indefinidamente.

A continuación, un programa que calcula el factorial de un número entero positivo:

1 # include <iostream >2 using namespace std;34 long int factorial (int n){5 if(n == 1){6 return 1;7 } else {8 return n* factorial (n -1);9 }

10 };1112 int main (){13 long int n;14 cout << " Ingrese un numero entero positivo : " << endl;15 cin >> n;16 cout << n << "! = " << factorial (n) << endl;1718 return 0;19 }

La recursividad facilita la escritura de código que trabaja con estructuras de datos o problemasque tienen una naturaleza recursiva como la estructura de datos árbol. Además, produce uncódigo más legible para este tipo de problemas.

La serie de Fibonacci es una sucesión infinita de números naturales:

0, 1, 1, 2, 3, 5, 8, 13, 21, . . .

Sus dos primeros términos son 0 y 1, los restantes términos se obtienen a partir de la suma delos dos anteriores.

Escriba un programa que permita obtener el n-ésimo elemento de la serie de Fibonacci.

1 # include <iostream >2 using namespace std;34 int fibonacci (int n){5 if(n == 0){


6 return 0;7 } else if(n == 1){8 return 1;9 } else {

10 return fibonacci (n -1) + fibonacci (n -2);11 }12 };1314 int main (){15 long int n;16 cout << " Serie de Fibonacci " << endl;17 cout << " Ingrese la posicion del elemento a mostrar " << endl;18 cin >> n;19 cout << "El n- esimo elemento es : " << fibonacci (n) << endl;2021 return 0;22 }

5.7. Paso por variable o referenciaUna función en C++ sólo tiene un valor de retorno. Sin embargo, a veces se necesita que unafunción devuelva más de un valor; por ejemplo, podríamos necesitar una función que devuelvatanto el máximo como el mínimo de los valores recibidos como parámetros. Se puede conseguirdevolver más de un valor utilizando como tipo de retorno una estructura que contenga tantoscampos como valores a devolver. Ver ejemplo de la sección 5.3. Esta solución no es muy elegantepues implica la definición de una estructura con el único objeto de almacenar los valores deretorno.

En C++ se pueden utilizar los parámetros formales de una función para que la misma devuelvadatos. En esta sección nos centraremos en estudiar como utilizar variables de tipo referencia.

5.7.1. Referencias

Una referencia es un nombre alternativo para un dato u objeto. La sintaxis T& significa refe-rencia a un objeto del tipo T.

Una variable de tipo referencia debe iniciarse en su definición con un objeto del mismo tipo queel tipo asociado a la referencia. Al objeto con que se inicia la referencia lo llamaremos el objetoreferenciado por la referencia.

Una referencia es por así decirlo un alias o etiqueta de una variable.

A continuación, un programa que define una referencia y muestra la dirección de memoria en laque se almacena una variable:

1 # include <iostream >2 using namespace std;34 int main (){5 int x=4;


6 // Definición e inicialización de la referencia7 int & ref_x = x;89 cout << " Valor del objeto referenciado : " << ref_x << endl;

10 cout << " Direccion del objeto referenciado : " << &x << endl;1112 return 0;13 }


Ahora, analicemos que sucede si se modifica el valor de x:

1 # include <iostream >2 using namespace std;34 int main (){5 int x=4;6 // Definición e inicialización de la referencia7 int & ref_x = x;89 cout << " Valor del objeto referenciado : " << ref_x << endl;

10 cout << " Direccion del objeto referenciado : " << &x << endl;1112 // Modificamos el valor de x13 x = 9;1415 cout << " Valor del objeto referenciado : " << ref_x << endl;16 cout << " Direccion del objeto referenciado : " << &x << endl;1718 return 0;19 }

Una referencia siempre tiene asociado el mismo objeto referencia, a saber, el objeto con que se hainiciado la referencia. Una vez iniciada una referencia, cuando un programa utiliza la referenciarealmente se trabaja con su objeto referenciado.

A continuación, otro programa que intenta mostrar el manejo de referencias:

1 # include <iostream >


2 using namespace std;34 int main (){5 int x = 6;6 int v[] = {1 ,2};7 int &r1 = x;8 int &r2 = v[0];9

10 cout << x << "\t" << v[0] << "\t" << v[1] << endl;11 r1 = 4;12 r2 ++;13 cout << x << "\t" << v[0] << "\t" << v[1] << endl;14 cout << r1 << "\t" << r2 << endl;15 return 0;16 }

Analicemos el estado de la pila en algunos momentos de la ejecución del programa:


5.7.2. Paso por referencia

Las referencias se utilizan principalmente para implementar el paso por variable o por referencia.El paso por variable se puede utilizar para que una función devuelva información mediante unparámetro.

A continuación, un primer programa que usa referencias:

1 # include <iostream >2 using namespace std;34 // Paso por variable5 void incremento1 (int a) {6 a = a + 1;7 return ;8 }9

10 // Paso por referencia11 void incremento2 (int &a) {12 a = a + 1;13 return ;14 }


1516 int main () {17 int x = 3;18 // Funcion con paso por variable19 incremento1 (x);20 cout << "x tiene el valor : " << x << endl;2122 int y = 3;23 // Funcion con paso por referencia24 incremento2 (y);25 cout << "y tiene el valor : " << y << endl;2627 return 0;28 }

Notemos que los cuerpos de las funciones incremento1 e incremento2 son iguales, sin embargo,los parámetros formales de la función son diferentes, para la primera función se hace un pasopor variable, mientras que la segunda función realiza un paso por referencia.

Para el siguiente programa nos encontramos interesados en realizar la división entre dos númerosenteros y obtener dos resultados: el cociente y el residuo.

1 # include <iostream >2 using namespace std;34 int division (int dividendo , int divisor , int & residuo ){5 residuo = dividendo % divisor ;6 return dividendo / divisor ;7 }89 int main () {

10 int num , den , res;11 cout << " Ingrese el dividendo y divisor : " << endl;12 cin >> num >> den;13 int cociente = division (num , den , res );1415 cout << "El cociente es : " << cociente << endl;16 cout << "El residuo es : " << res << endl;17 cout << "Se verifica que : " << cociente << "*" << den18 << "+" << res << "=" << num << endl;1920 return 0;21 }

En el programa anterior a partir de una referencia es posible obtener 2 o más valores resultantesde la ejecución de una función.

A continuación, retomamos nuestro trillado ejemplo del mínimo y máximo de dos números:

1 # include <iostream >2 using namespace std;3


4 void MaxMin ( double x, double y, double &min , double &max ){5 if(a > b){6 max = x;7 min = y;8 } else {9 max = y;

10 min = x;11 }12 return ;13 }1415 int main (){16 double a, b, maximo , minimo ;17 cout << " Ingrese dos números : " << endl;18 cin >> a >> b;19 // Invocamos a la función20 MaxMin (a, b, minimo , maximo );21 // Imprimos los resultados22 cout << "El maximo es : " << maximo << endl;23 cout << "El minimo es : " << minimo << endl;24 return 0;25 }

Ejecutemos el anterior programa con: a = 3 y b = 7


El programa incluye una función, llamada MaxMin, cuyos dos últimos parámetros formales,max y min, tienen semántica de paso por referencia. Cuando se invoca a la función MaxMin,max y min se inician con los dos objetos pasados como parámetros reales. Cuando la función


MaxMin realiza alguna modificación o consulta sobre las variables max o min realmente estámodificando o consultando los objetos referenciados por estas dos variables. Esto permite quetras la ejecución de la función MaxMin, la función main pueda consultar los valores de máximoy mínimo calculados por la función MaxMin.

Cuando la función MaxMin asigna valores a las referencias max y min los valores asignados sealmacenan en las variables maximo y minimo respectivamente. Esto permite que tras ejecutarla función MaxMin las variables maximo y minimo contengan los dos valores calculados porMaxMin.

Cuando un parámetro formal es de tipo referencia, el parámetro real utilizado en la invocacióndebe ser una variable, si se usa el calificativo const como calificador del parámetro formal no esnecesario utilizar una variable, de ahí el nombre de paso por variable.

5.8. Paso de parámetros tipo estructuraEl paso de parámetros de tipo estructura se realiza de la misma manera que el de un tipo básico.El paso de una estructura como parámetro por valor de una función puede ser algo ineficientepues implica la iniciación de la estructura de todos sus campos. Cuantos más campos tenga laestructura más costoso resultará su paso por valor.

A continuación, un ejemplo de la suma de números complejos:

1 # include <iostream >2 using namespace std;34 struct complejo {5 double real;6 double imaginario ;7 }89 complejo suma( complejo x, complejo y){

10 complejo res;11 res.real = x.real + y.real;12 res. imaginario = x. imaginario + y. imaginario ;13 return res;14 }1516 void impcomplejo ( complejo w){17 cout << w.real << " + " << w. imaginario << ".i" << endl;18 }1920 int main (){21 complejo x,y,z;22 cout << " Ingrese el primer complejo : " << endl;23 cin >> x.real;24 cin >> x. imaginario ;25 cout << " Ingrese el segundo complejo : " << endl;26 cin >> y.real;27 cin >> y. imaginario ;28 z = suma(x,y);29 cout << "El resultado es : ";


30 impcomplejo (z);3132 return 0;33 }

5.9. Sobrecarga de funcionesLa sobrecarga de funciones es una característica de C++ que no está presente en la gran mayo-ría de lenguajes de programación. Consiste en poder definir más de una función con el mismonombre, siempre que los parámetros de las funciones difieran en número o tipo.

A continuación, un programa que presenta una sobrecarga:

1 # include <iostream >2 using namespace std;34 double maximo ( double x, double y){5 if(x > y)6 return x;7 return y;8 };9

10 double maximo ( const double x[], int dim ){11 double max = x[0];12 for(int i = 1; i < dim; i++){13 if(x[i] > max ){14 max = x[i];15 }16 }17 return max;18 };1920 int main (){21 double a,b;22 double vec [5];23 cout << " Ingrese dos números : " << endl;24 cin >> a >> b;25 cout << "El mayor valor es : " << maximo (a,b) << endl;26 cout << " Ingrese 5 números : " << endl;27 for(int j = 1; j <= 5; j++){28 cin >> vec[j -1];29 }30 cout << "El máximo valor ingresado es : " << maximo (vec , 5) << endl;3132 return 0;33 }


5.10. Paso de parámetros de tipo vectorUn parámetro de tipo vector se especifica de la misma forma que se define una variable de tipovector, salvo que no es necesario especificar su tamaño. Como a través de una variable de tipovector no es posible saber cuántos elementos almacena el vector, se utiliza otro parámetros pararecibir el número de elementos que almacena el vector.

A continuación, un programa que recibe como parámetro un vector:

1 # include <iostream >2 # include <cmath >3 using namespace std;45 void cuadrado ( double x[], int dim ){6 for(int i = 0; i < dim; i++){7 x[i] = pow(x[i] ,2);8 }9 };

1011 void impvector ( double x[], int dim ){12 for(int i = 0; i < dim; i++){13 cout << x[i] << "\t";14 }15 };1617 int main (){18 double vec [5];19 cout << " Ingrese 5 números : " << endl;20 for(int j = 1; j <= 5; j++){21 cin >> vec[j -1];22 }23 cuadrado (vec , 5);24 cout << "Los números al cuadrado son : " << endl;25 impvector (vec ,5);26 return 0;27 }

Una variable de tipo vector almacena la dirección de memoria a partir de la cual se almacenanlos elementos del vector. Por lo tanto, lo que recibe un parámetro formal de tipo vector es ladirección de memoria donde se almacena un vector. Al recibir la dirección de memoria dondese almacena el vector, la función tiene total acceso a los elementos originales del vector y, portanto, las modificaciones que realice en los elementos del vector serán visibles al terminar laejecución de la función.

A continuación, se muestra un programa que genera estadísticas a partir de la información de10 estudiantes:

1 # include <iostream >2 using namespace std;34 void leer( double a[]){5 int i;6 cout << " Ingrese las estaturas de los alumnos :" << endl;


7 for(i=0; i <10; i++){8 cout << " Alumno " << i+1 << ": ";9 cin >> a[i];

10 }11 }1213 double estatura_media ( double a[]){14 double media = 0;15 int i;16 for(i=0; i <10; i++){17 media = media + a[i];18 }19 media = media / 10;20 return media ;21 }2223 void max_min ( double a[], double &max , double &min ){24 int i;25 max = min = a[0];26 for(i=1; i <10; i++){27 if(a[i]>max ){28 max = a[i];29 } else {30 if(a[i]<min)31 min = a[i];32 }3334 }35 }3637 void cuantos_mayor_menor_media ( double a[], double media ,38 int & mayores_media , int & menores_media ){39 int i;40 for(i=0; i <10; i++){41 if(a[i] > media)42 mayores_media ++;43 else if(a[i] < media)44 menores_media ++;45 }46 }4748 void mostrar_resultados ( double a[], double media , double mayor ,49 double menor , int mayores_media , int menores_media ){50 int i;51 cout << " Estatura de los alumnos de la clase " << endl;52 cout << " -----------------------------------" << endl;53 for(i=0; i <10; i++){54 cout << " Alumno " << i+1 << ": " << a[i] << endl;55 }56 cout << " Mayor estatura : " << mayor << endl;57 cout << " Menor estatura : " << menor << endl;


58 cout << " Estatura media : " << media << endl;59 cout << "Hay " << mayores_media << " alumnos con estatura ";60 cout << " superior a la media " << endl;61 cout << "Hay " << menores_media << " alumnos con estatura ";62 cout << " inferior a la media " << endl << endl;63 }6465 int main (){66 double estaturas [10] , media , mayor , menor;67 int cont_mas = 0, cont_menos = 0;68 leer( estaturas );69 max_min (estaturas ,mayor ,menor );70 media = estatura_media ( estaturas );71 cuantos_mayor_menor_media (estaturas ,media ,cont_mas , cont_menos );72 mostrar_resultados (estaturas ,media ,mayor ,menor ,cont_mas ,73 cont_menos );74 return 0;75 }

5.11. Paso de parámetros de tipo arrayPara realizar el paso de un array a una función se debe tener en cuenta lo siguiente:

En la función se debe declarar el parámetro como un array del tipo adecuado. En losarrays unidimensionales no es necesario especificar el tamaño por lo tanto aparecerán loscorchetes vacíos.

En la llamada a la función a la que se envía el array, el nombre del array aparecerá solo,sin corchetes ni índices

Los arrays en C++ se pasan siempre a las funciones por referencia. El nombre de un arrayrealmente es un puntero que contiene la dirección de memoria donde comienza el array, o loque es lo mismo, la dirección de memoria del primer elemento. Cuando se pasa un array a unafunción, la función recibe la dirección de memoria donde se encuentra el primer elemento delarray. Por lo tanto, la función trabaja sobre el array original.

No es necesario utilizar el operador & en el paso de arrays a funciones para indicar que se hacepor referencia ya que siempre pasan por referencia.

A continuación, un programa que pasa un array por una función:

1 # include <iostream >2 using namespace std;34 const int MAXFIL = 20;5 const int MAXCOL = 30;67 void leerMatriz (int matriz [][ MAXCOL ], int nf , int nc){8 int fila , col;9 for (fila =0; fila < nf; fila ++ ){

10 cout << "\ nFila : " << fila +1 << endl;11 for (col =0; col < nc; col ++){


12 cout << " Elemento : " << col +1 <<": ";13 cin >> matriz [fila ][ col ];14 }15 }16 }1718 void sumarMatrices (int matriz1 [][ MAXCOL ], int matriz2 [][ MAXCOL ],19 int matriz3 [][ MAXCOL ], int nf ,int nc){20 int fila , col;21 for (fila =0; fila < nf; fila ++ ){22 for (col =0; col < nc; col ++)23 matriz3 [fila ][ col] = matriz1 [fila ][ col] + matriz2 [fila ][ col ];24 }25 }2627 void mostrarResultado (int matriz [][ MAXCOL ], int nf , int nc ){28 int fila , col;29 for (fila =0; fila < nf; fila ++ ){30 for (col =0; col < nc; col ++)31 cout << matriz [fila ][ col] << "\t";32 cout << endl;33 }34 }3536 int main (){37 int nfilas ,ncols;38 int matriz1 [ MAXFIL ][ MAXCOL ];39 int matriz2 [ MAXFIL ][ MAXCOL ];40 int matriz3 [ MAXFIL ][ MAXCOL ];4142 do{43 cout <<"\ nIntroduce numero de filas . Maximo " << MAXFIL << ": ";44 cin >> nfilas ;45 } while (nfilas <=0 or nfilas >MAXFIL );4647 do{48 cout <<"\ nIntroduce numero de columnas . Maximo " <<MAXCOL <<": ";49 cin >> ncols ;50 } while (ncols <=0 or ncols >MAXCOL );5152 // Lectura de datos de la primera matriz53 cout << "\n Introduce datos de la primera matriz ";54 leerMatriz (matriz1 , nfilas , ncols );5556 // Lectura de datos de la segunda matriz57 cout << "\n Introduce datos de la segunda matriz ";58 leerMatriz (matriz2 , nfilas , ncols );5960 // Calcular la suma de las dos matrices61 sumarMatrices (matriz1 , matriz2 , matriz3 , nfilas , ncols );62


63 // Mostrar el resultado por pantalla64 cout << "\ nmatriz 1:" << endl;65 mostrarResultado (matriz1 , nfilas , ncols );6667 cout << "\ nmatriz 2:" << endl;68 mostrarResultado (matriz2 , nfilas , ncols );6970 cout << "\ nmatriz 3 = matriz1 + matriz2 " << endl;71 mostrarResultado (matriz3 , nfilas , ncols );7273 return 0;74 }

6 | Punteros

Los punteros son uno de los tipos de datos más temidos en C++. Sin embargo, también son losmás versátiles y los que mayor potencia proporcionan.

Su uso permite el paso de argumentos por referencia, la construcción de estructuras dinámicasde datos y la mejora en la velocidad de ejecución de algunos algoritmos. Sin embargo, el maluso de los punteros puede producir graves errores en la compilación, en algunos casos difícilesde detectar.

6.1. Qué es un puntero ?Un puntero es una variable que contiene una dirección de memoria y permite modificar elcontenido de la memoria. Su declaración se realiza de forma análoga al resto de variables, susintaxis es la siguiente:

tipo *nombre;

donde nombre es nombre de la variable puntero y tipo es el tipo de objeto cuya dirección se vaa almacenar. Es importante que se conozca de antemano a qué va a apuntar un puntero.

A continuación, un primer programa en el que se declaran variables de tipo puntero:

1 # include <iostream >2 using namespace std;34 int main (){5 int i=5;6 int *p, *q;7 // Se almacena la dirección de i8 p = &i;9 cout << "La direccion de p es : " << p << endl;

10 // Se pasa la dirección almacenada en p11 q=p;12 cout << "La direccion de q es : " << q << endl;13 return 0;14 }

A continuación, se muestra un programa que emplea un puntero sobre una función:

1 # include <iostream >2 using namespace std;34 int * Par(int vec [], int tam ){5 for(int j=0; j<tam; j++){

63

CAPÍTULO 6. PUNTEROS 64

6 if(vec[j] %2 == 0){7 return &vec[j];8 }9 }

10 return 0;11 }1213 int main (){14 const int dim =10;15 int v[dim ];16 cout << " Ingrese 10 valores enteros " << endl;17 for(int i=0; i<dim; i++){18 cin >> v[i];19 }20 int *npar = Par(v, dim );2122 if(npar !=0){23 cout << "El primer elemento par del vector es : "24 << *npar << endl;25 } else {26 cout << "El vector no tiene valores pares ";27 }2829 delete [] npar;3031 return 0;32 }

Después de usar un puntero, especialmente si trabajamos con arreglos o matrices, es recomen-dable liberar la memoria utilizada con la función delete.

6.2. Puntero nuloEs posible asignarle el valor cero a un puntero:

int *pun = 0;

En la iniciación previa el literal 0 es un entero que se convierte implícitamente a una direcciónde memoria. Lo interesante es que la conversión implícita produce una dirección de memoria enla que no puede estar almacenado ningún objeto. Por lo tanto, en C++ se utiliza el valor 0 paraindicar una dirección que no apunta a nada, es decir, a ningún objeto.

En el momento de las declaraciones de variables, si no se puede asignar la dirección exacta,asignar un valor NULL para la variable puntero es una buena práctica de programación.

int *pun = NULL;

6.3. Parámetros por referenciaAl enviar un parámetro a una función todo lo que se haga con dicho parámetro dentro de lamisma no tiene efecto por fuera. Por ejemplo, si a una función se envía una variable cuyo valores 10 y al interior de la función le sumamos un 5, después de la ejecución de la función el valor


de la variable seguirá siendo 10 en lugar de 15. Lo que pasó al interior de la función se quedóallí. Para solucionar esto, si queremos que el valor cambie definitivamente, usamos punteros parapasar no el valor del parámetro sino una referencia a éste.

A continuación, una función que emplea punteros para modificar el valor de una variable:

1 # include <iostream >2 using namespace std;34 int fun(int valor ){5 valor += 5;6 return valor;7 }89 int funPuntero (int* valor ){

10 * valor += 5;11 return *valor ;12 }1314 int main (){15 int numero = 10;16 cout << " Numero antes de llamar a fun : " << numero << endl;17 // Llamado a fun (se pasa el valor )18 fun( numero );19 // Resultado luego del llamado a fun20 cout << " Numero luego de llamar a fun : " << numero << endl;2122 cout << " Numero antes de llamar a funPuntero : " << numero << endl;23 // Llamado a funPuntero (se pasa la dirección de memoria )24 funPuntero (& numero );25 // Resultado luego del llamado a funPuntero26 cout << " Numero luego de llamar a funPuntero : " << numero << endl;2728 return 0;29 }

A continuación, nuestra función del máximo y mínimo en la versión con punteros:

1 # include <iostream >2 using namespace std;34 void MaxMin ( double x, double y, double *max , double *min ){5 if(x>y){6 *max = x;7 *min = y;8 } else {9 *max = y;

10 *min = x;11 }12 return ;13 }1415 int main (){


16 double a, b, maximo =0, minimo =0;17 cout << " Ingrese dos numeros " << endl;18 cin >> a >> b;19 MaxMin (a, b, &maximo , & minimo );20 cout << " Maximo : " << maximo << endl;21 cout << " Minimo : " << minimo << endl;22 return 0;23 }

6.4. Aritmética de punteros y vectoresDada una expresión p de tipo puntero a un dato de tipo T y una expresión e de tipo entero, laexpresión p+e produce un valor de tipo puntero a un dato de tipo T y de valor p+e*sizeof(T),donde sizeof(T) es una expresión que devuelve el tamaño en bytes ocupado por un dato detipo T. Es decir, si p vale 1000 y apunta a un entero, entonces p + 2 vale 1008, suponiendoque un entero ocupa cuatro bytes, o sea, que sizeof(int) vale 4. Como los elementos de unvector ocupan posiciones contiguas de un vector, se puede utilizar un puntero para recorrer suselementos.

Tipo sizeofbool 1int 4

double 8string 8

Si p es un puntero que apunta al primer elemento de un vector v, es decir, p = &v[0], entonces laexpresión p + i, donde i es una expresión entera, equivale a &v[i]. Por lo tanto, *(p+i) equivalea v[i].

A continuación, un programa que muestra la aritmética de punteros:

1 # include <iostream >2 using namespace std;34 int main () {5 int v[5] = {2 ,4 ,6 ,8 ,10};6 int * p = v;7 cout << "La dirección de p es :" << p << endl;8 cout << "El valor de p es :" << *p << endl;9 bool e=1;

10 cout << "La dirección de p+e es :" << p+e << endl;11 cout << "El valor de p+e es :" << *(p+e) << endl;12 return 0;13 }

En la expresión *(p+i) los paréntesis son necesarios, puesto que el operador desreferencia, *,tiene mayor precedencia que el operador suma, +, lo que implica que la expresión *p+i equivalea la expresión (*p)+i, es decir, significa sumarle i al elemento al que apunta p, como en el ejemplop vale &v[0], p + i equivale a v[0]+i.

A continuación, un programa que recorre un vector usando punteros:


1 # include <iostream >2 using namespace std;34 int main (){5 int v[8] = {1 ,3 ,5 ,7 ,2 ,4 ,6 ,8};6 int *p = &v[0];7 for(int i = 0; i < 8; i++)8 cout << *(p + i) << endl;9 return 0;

10 }

También es posible restar dos expresiones de tipo puntero, pero la resta sólo tiene sentido silas dos expresiones apuntan a elementos del mismo vector. En dicho caso, la resta devuelve elnúmero de posiciones que existen entre los dos elementos del vector a los que apuntanlos punteros.

A continuación, se muestra una modificación (obtención de la posición) del programa que mues-tra el primer elemento par de un vector:

1 # include <iostream >2 using namespace std;34 int * Par(int vec [], int tam ){5 for(int j=0; j<tam; j++){6 if(vec[j] %2 == 0){7 return &vec[j];8 }9 }

10 return 0;11 }1213 int main (){14 const int dim =10;15 int v[dim ];16 cout << " Ingrese 10 valores enteros " << endl;17 for(int i=0; i<dim; i++){18 cin >> v[i];19 }20 int *npar = Par(v, dim );2122 if(npar !=0){23 cout << "El primer elemento par del vector es : " << *npar << endl;24 cout << "Ocupa la posición : " << npar - &v[0] << endl;25 } else {26 cout << "El vector no tiene valores pares ";27 }2829 delete [] npar;3031 return 0;32 }

En el siguiente programa se va a implementar el algoritmo de selección, que sirve para ordenar


de forma creciente una secuencia de elementos almacenados en un vector. Dado un vector de nelementos, el algoritmo selecciona el mínimo de los elementos del vector y lo intercambia por elelemento que ocupa la primera posición del vector, a continuación, selecciona el mínimo entrelas posiciones 2 y n y lo intercambia por el elemento de la posición 2.

En general, en la iteración i-ésima se selecciona el mínimo entre las posiciones i y n, luego seintercambia por el valor en la posición i.

1 # include <iostream >2 # include <cstdlib >3 using namespace std;45 int * minvec (int v[], int *pos , int *dim ){6 int *min;7 min=pos;8 for(int i=0; i<dim -pos;i++){9 if (*( pos+i) < *min ){

10 min = pos+i;11 }12 }13 return min;14 }1516 void intercambiar (int v[], int *x, int *y){17 int aux;18 aux = *x;19 *x = *y;20 *y = aux;21 }2223 void Ordenar (int v[], int dim ){24 int * minimo ;25 for(int k=0; k<dim; k++){26 minimo = minvec (v, &v[k], &v[dim ]);27 intercambiar (v, &v[k], minimo );28 }29 }3031 int main (){32 int n=10;33 int vec[n];34 srand(time(NULL ));35 cout <<" Vector generado :" << endl;36 for(int j=0; j<n; j++){37 vec[j]= rand () %31;38 cout << vec[j] << "\t";39 }4041 Ordenar (vec ,n);42 cout << " Vector ordenado " << endl;43 for(int j=0; j<n; j++){


44 cout << vec[j] << "\t";45 }46 return 0;47 }

7 | Librería STL

La STL (Standard Template Library) es una librería estándar de estructuras de datos y algo-ritmos que forma parte del C++. Esto garantiza que cualquier compilador incluye esta librería,por lo que cualquier usuario puede usarla para sus programas.

El principal objetivo de la STL es evitar que los usuarios tengan que programar, una y otravez, aquellos algoritmos o estructuras de datos fundamentales, como por ejemplo: algoritmos deordenacion, o estructuras de datos.

7.1. VectoresUn vector es la estructura de datos más básica: es un arreglo que almacena n elementos del mismotipo en n posiciones consecutivas de memoria. Si el vector se llama VEC, se puede acceder a loselementos mediante las expresiones: VEC[0], VEC[1], . . . , VEC[n-1]. Para usar vectores de laSTL es necesario añadir la siguiente línea en el preámbulo del programa.

#include <vector>

La sintaxis para crear vectores es la siguiente:

vector <tipo> nombre(longitud, valor por defecto)

A continuación, un primer programa que muestra como crear vectores usando la STL:1 # include <iostream >2 # include <vector >3 using namespace std;45 int main (){6 // Vector de 5 elementos enteros7 vector <int > VEC (5);8 VEC [0]=1;9 VEC [4]=3;

10 for(int k=0; k <5; k++){11 cout << VEC[k] << "\t";12 }1314 // Vector de 3 elementos string , inicializado con "EPN"15 vector <string > v(3, "EPN");16 for(int j=0; j <3; j++){17 cout << v[j] << "\t";18 }1920 return 0;21 }

70

CAPÍTULO 7. LIBRERÍA STL 71

A diferencia de los vectores tradicionales del C++, los vectores de la STL pueden cambiar detamaño durante la ejecución del programa, además, tienen la muy útil propiedad de actuar co-mo variables normales y corrientes: podemos asignarlos, compararlos, copiarlos, pasarlos comoparámetro, hacer que una función los devuelva, etc.

A continuación, un programa en el cual una función devuelve un vector:

1 # include <iostream >2 # include <vector >3 using namespace std;45 bool EsPrimo (int n){6 bool m = true;7 for(int k=2; k<n; k++){8 if(n %k ==0){9 m = false ;

10 break ;11 }12 }13 return m;14 }1516 vector <int > Primos (int n){17 vector <int > res;18 for(int j=2; j<n; j++){19 if( EsPrimo (j)){20 res. push_back (j);21 }22 }23 return res;24 };252627 int main (){28 int num;29 cout << " Ingrese un número entero positivo mayor a 1 : " << endl;30 cin >> num;3132 vector <int > vec;33 vec = Primos (num );3435 for(int i=0; i<vec.size (); i++){36 cout << vec[i] << "\t";37 }3839 return 0;40 }

Las estructuras de la STL poseen métodos (funciones propias) que facilitan el trabajo, entre losmétodos más empleados podemos mencionar:

size: Retorna el número de elementos que posee el vector.


resize: Modifica el tamaño de un vector, borrando o añadiendo elementos al final, segúnconvenga.

empty: Contrasta si el vector está vacío.

front: Accede al primer elemento del vector.

back: Accede al primer elemento por fuera del vector (elemento posterior al último).

push_back: Añade un elemento al final del vector.

pop_back: Elimina el último elemento del vector.

erase: Elimina todos los elementos de un vector.

Los vectores y, en general, todos los tipos STL, tienen lo que se llama semántica de valor que,además de otras cosas, quiere decir que cuando pasamos un vector como parámetro en un función,lo que se hará es copiar todos sus datos a la función que lo recibe. Lo cual puede generar quenuestros programas sean demasiado lentos. Por lo tanto, siempre que pasemos un vector u otrocontenedor de la STL por parámetro es conveniente pasarlo como referencia:

FUN(const vector <tipo> &VEC)

si no vamos a modificar el vector. Mientras que emplearemos la siguiente sintaxis:

FUN(vector <tipo> &VEC)

si nuestra intención es modificar el vector VEC.

Esto garantiza que, en ambos casos, la función trabaje con el vector original, y no con una copiadel mismo.

7.1.1. Iteradores

Una de las operaciones más comúnes a realizar con un vector consiste en recorrer todos loselementos que contiene. Por lo general, esta tarea se la ha venido realizando mediante un indice.

A continuación, un programa que recorre todos los elementos de un vector:

1 # include <iostream >2 # include <vector >3 using namespace std;45 int main (){6 vector <int > VEC;7 int num;8 cout << " Ingrese n valores enteros ( digite -999 para finalizar ): " << endl;9 cin >> num;

10 while (num != -999){11 VEC. push_back (num );12 cin >> num;1314 }1516 cout << "El vector ingresado es : " << endl;17 for(int i=0; i<int(VEC.size ()); i++){


18 cout << VEC[i] << "\t";19 }2021 return 0;22 }

La STL ofrece otro modo de recorrer los vectores distinto al método tradicional de usar uníndice, a partir de los iteradores.

1 # include <iostream >2 # include <vector >3 using namespace std;45 int main (){6 vector <int > VEC;7 int num;8 cout << " Ingrese n valores enteros ( digite -999 para finalizar ): " << endl;9 cin >> num;

10 while (num != -999){11 VEC. push_back (num );12 cin >> num;1314 }1516 cout << "El vector ingresado es : " << endl;17 for( vector <int >:: iterator it=VEC.begin (); it!= VEC.end (); ++it ){18 cout << *it << "\t";19 }2021 return 0;22 }

Esencialmente, un iterador es una variable de tipo vector<tipo>::iterator que actúa como unapuntador a un elemento del vector. Si it es un iterador, las operaciones ++it y –it sirven paradesplazar el iterador hacia la derecha o izquierda del vector, y la operación *it devuelve el ele-mento apuntado por el iterador. Los iteradores v.begin() y v.end() son dos iteradores especialesque apuntan al primer elemento del vector, y al primer elemento fuera del vector.

Los iteradores no son punteros, pero actúan como si lo fuesen. En cierto modo, un iterador esun puntero seguro, que no sólo sirve para apuntar a un valor de un tipo, sino que además sabedesplazarse por el contenedor donde habita.

La STL permite ordenar muy fácilmente los elementos de un vector<T>: basta con hacer unallamada a la función sort, misma que se encuentra disponible dentro de la librería algorithm.

1 # include <iostream >2 # include <vector >3 # include <algorithm >4 using namespace std;56 int main (){


7 vector <int > VEC;8 int num;9 cout << " Ingrese n valores enteros ( digite -999 para finalizar ): " << endl;

10 cin >> num;11 while (num != -999){12 VEC. push_back (num );13 cin >> num;1415 }1617 cout << "El vector ingresado es : " << endl;18 for( vector <int >:: iterator it=VEC.begin (); it!= VEC.end (); ++it ){19 cout << *it << "\t";20 }2122 cout << endl;2324 cout << "El vector ordenado es : " << endl;25 sort(VEC. begin (), VEC.end ()); // orden ascendente2627 for( vector <int >:: iterator it=VEC.begin (); it!= VEC.end (); ++it ){28 cout << *it << "\t";29 }3031 return 0;32 }

7.2. MatricesUna matriz no es más, pues, que un vector de filas, donde cada fila es un vector de elementos.La sintaxis a utilizarse en la creación de matrices con la librería STL es la siguiente:

vector<vector<tipo> > nombre(número de filas)

A continuación, un programa que define matrices de la librería STL:

1 # include <iostream >2 # include <vector >3 using namespace std;45 int main (){6 vector < vector <int > > M(5); // Matriz de 5 filas vacías78 for(int i=0; i<M.size (); i++) {9 M[i]. resize (3); // ahora obtenemos matriz (5 x3)

10 }1112 cout << " Llenado de la matriz " << endl;13 for(int i=0; i<M.size (); i++) {14 for(int j=0; j<M[i]. size (); j++) {15 M[i][j] =i+j;16 }


17 }18 return 0;19 }

A continuación, un programa que recibe un número decimal y calcula el número binario asociado,y viceversa:

1 # include <iostream >2 # include <vector >3 # include <cmath >4 # include <algorithm >5 using namespace std;67 int Mitad(int *n){8 *n /=2;9 }

1011 vector <int > numero_binario (int n){12 vector <int > S;13 int *m;14 m=&n;15 do{16 S. push_back (*m %2);17 Mitad(m);18 } while (*m >=1);19 return S;20 }2122 int numero_decimal ( const vector <int > &M){23 int longitud = int(M.size () -1);24 int numero =0;25 for(int i=0; i<M.size (); i++){26 numero += M[i]* pow (2, longitud -i);27 }28 return numero ;29 }303132 int main (){33 vector <int > R;34 int num;35 cout << " Ingrese el valor de n:" << endl;36 cin >> num;3738 R = numero_binario (num );3940 for(int i=1; i <=R.size (); i++){41 cout << R[int(R.size ())-i] << "\t";42 }4344 int b;45 vector <int > BIN;


46 cout << " Ingrese un numero binario (para finalizar teclea 2)" << endl;47 cin >> b;48 while (b !=2){49 BIN. push_back (b);50 cin >> b;51 }5253 cout << "El numero decimal es : " << numero_decimal (BIN) << endl;5455 return 0;56 }

8 | Clases y Objetos

Las variables de los tipos fundamentales de datos no son suficientes para modelar adecuadamenteobjetos del mundo real. Por ejemplo, no se puede trabajar directamente en C++ con los númeroscomplejos, pero si se definen las variables parte real y parte imaginaria, se las puede juntar enuna estructura llamada Complejo.

x = a + bi

donde, a es la parte real y b la parte compleja.

La solución que hemos adoptado hasta el momento es definir un nuevo tipo, normalmente unaestructura (struct), y definir funciones y procedimientos que procesarán tales estructuras. Estasolución presenta varios inconvenientes que ilustraremos a continuación.

Supongamos que vamos a escribir un programa en C++ en el que vamos a procesar númeroscomplejos. C++ carece de un tipo predefinido adecuado para representar dichos números, demanera que decidimos definir un tipo Complejo de la siguiente manera:

struct Complejo {double real;double imaginaria;

}

Además de definir la estructura Complejo, debemos definir funciones y procedimientos que so-porten operaciones básicas sobre este tipo. Por ejemplo, se pueden incluir las siguientes decla-raciones:

bool EsComplejo(Complejo u);Complejo Suma(Complejo u, Complejo v);Complejo Producto(Complejo u, Complejo v);double ParteReal(Complejo u);double ParteImaginaria(Complejo v);

Sería deseable que una vez que hemos definido el tipo Complejo y sus operaciones básicas, estenuevo tipo se pudiera emplear como si fuera un tipo predefinido de C++.

El propósito de las clases en C++ es facilitar al programador una herramienta que le permitadefinir un nuevo tipo que se pueda usar como un tipo predefinido de C++.

En este capítulo intentamos mostrar que es posible definir variables de este nuevo tipo de lamisma manera que con variables de tipos básicos. Se podrá crear, manipular y destruir tantosobjetos de tipo Complejo como se quiera. De esta manera veremos cómo C++ incorpora lanoción de clase del paradigma de Orientación a Objetos.

La palabra class es la palabra reservada para implementar este concepto.

77

CAPÍTULO 8. CLASES Y OBJETOS 78

8.1. Definición de clasesLas clases se definen en C++ mediante una construcción dividida en dos partes: una parteprivada (private) que contiene algunos detalles de la implementación y funcionamiento, y unaparte pública (public) que contiene todas las instrucciones de uso de la clase (métodos). Lasintaxis de uso es la siguiente:

class Complejo {private:

// Implementacion clase (atributos)double real;double imaginario;

public:// Métodosvoid asigna_real(double a);void asigna_imag(double b);double parte_real();double parte_imag();void suma(const Complejo &a, const Complejo &b);

}

Los campos real e imag son los atributos de la clase y codifican el estado de un objeto de laclase Complejo. Puesto que los atributos están declarados en la parte privada de la clase, formanparte de la implementación y no es posible acceder a ellos desde fuera de la clase. Su acceso estárestringido: sólo se puede acceder a ellos en la implementación de los métodos de la clase.

Los métodos que aparecen en la parte pública describen el comportamiento de la clase; es decir,las operaciones que podemos aplicar a un objeto del tipo Complejo. En particular, con estosmétodos podemos asignar valores a las partes real e imaginaria, leer las partes real e imaginaria,y sumar dos numeros complejos.

La implementación de los métodos de una clase se realiza fuera de la construcción de la clase.La sintaxis de la definición de un método es similar al de la definición de una función, exceptoque el nombre del método debe estar precedido por el nombre de la clase de la que forma parte.Así, el método asigna_real se implementa como sigue:

void Complejo:: asigna_real(double a){// Instrucciones del métodoreal = a;

}

donde el atributo real que aparece a la izquierda de la asignación es el atributo del argumentoimplícito. Incluso un método como parte_imaginaria, que aparentemente no tiene argumentos,recibe este argumento implícito que representa el objeto al que se aplica el método:

double Complejo::parte_imaginaria(){return imag;

}

Por otro lado, un método puede recibir argumentos explícitos de la clase a la que pertenece. Porejemplo, el método suma recibe dos argumentos explícitos de tipo Complejo. Al definir el métodosuma, podemos acceder a los atributos de los argumentos explícitos utilizando la notación puntousual, como si se tratara de una estructura:


void Complejo::suma(const Complejo& a, const Complejo& b){real= a.real + b.real;imag= a.imag + b.imag;

}

8.2. Uso de clasesUna vez que se ha definido e implementado una clase, es posible declarar objetos de esta clase yusarlos desde fuera de la clase como si se tratara de tipos predefinidos. En concreto, una variablede un tipo clase se declara como cualquier otra variable:

Complejo x; // Variable de tipo ComplejoComplejo y[5]; // Vector de Complejos

Sobre un objeto de una clase sólo pueden aplicarse las siguientes operaciones:

1. Aquellas definidas dentro de la clase.

2. La asignación.

3. El paso de parámetros por valor o referencia.

Aparte de la asignación y del paso de parámetros por referencia, toda la manipulación de losobjetos por parte del usuario debe hacerse a través de los métodos:

x.asigna_real(4);x.asigna_imag(5);

8.3. Constructores y destructoresComo todas las variables de C++, los objetos no están inicializados por defecto. Si el usuariodeclara objetos Complejo y opera con ellos sin asignarles un valor inicial, el resultado de laoperación no estará definido:

Complejo m,n,o;o.suma(m,n);

cout << o.parte_imag() << endl; // Imprime cualquier cosa

Para paliar este problema, C++ permite definir un método especial llamado el constructor dela clase, cuyo cometido es precisamente inicializar por defecto los objetos de la clase. Para quenuestros números complejos estén inicializados, basta añadir un constructor a la clase Complejode la siguiente manera:



public:Complejo(); // Añadimos el constructor// Métodosvoid asigna_real(double a);void asigna_imag(double b);double parte_real();


double parte_imag();void suma(const Complejo &a, const Complejo &b);

}

La implementación del constructor se hace fuera de la construcción de la clase. En nuestro caso,podemos optar por inicializar los complejos en 0 + 0i:

Complejo::Complejo(){real= 0;imaginario= 0;

}

Un constructor es un método muy diferente de todos los demás. En primer lugar, su nombrecoincide siempre con el de la clase a la que pertenece. Además, un constructor no es ni un pro-cedimiento ni una función, y por lo tanto no tiene asociado ningún tipo de retorno.

Por último, el usuario nunca invoca un constructor de manera explícita. Esto no tendría sentido,pues de lo que se trata es de que los objetos sean inicializados de manera implícita por C++,sin intervención alguna por parte del usuario. Por ello, el constructor de una clase es invocadoautomáticamente justo después de cada declaración un objeto de esa clase.

Complejo m,n,o;m.asigna_real(3);o.suma(m,n);

cout << o.parte_real() << endl;

Además del constructor por defecto, es posible asociar a una clase un constructor extendido enque se indiquen mediante argumentos los valores a los que se debe inicializar un objeto de laclase.



public:Complejo();Complejo(double a, double b); // Constructor extendido// Métodosvoid asigna_real(double a);void asigna_imag(double b);double parte_real();double parte_imag();void suma(const Complejo &a, const Complejo &b);

}

La implementación del constructor extendido es inmediata, basta emplear los argumentos parainicializar los atributos:

Complejo::Complejo(double a, double b){real = a;imaginario = b;

}


Para que C++ ejecute de forma automática el constructor extendido, basta añadir a la decla-ración de un objeto los valores a los que desea que se inicialice:

Complejo x(3,2); // Inicializa un complejo en 3 + 2i

De la misma manera que C++ permite definir constructores para los objetos de una clase,también es posible definir un destructor que se encargue de destruir los objetos automáticamente,liberando los recursos que pudieran tener asignados:



public:Complejo();Complejo(double a, double b);~Complejo(); // Destructor de la clase// Métodosvoid asigna_real(double a);void asigna_imag(double b);double parte_real();double parte_imag();void suma(const Complejo &a, const Complejo &b);

}

El nombre del destructor es siempre el de la clase a la que pertenece antecedido por el símbolo∼. Al igual que los constructores, los destructores se definen fuera de la construcción de la clasey no tienen tipo de retorno alguno:

Complejo::~Complejo(){// destruir el numero complejo

}

Es importante recordar que sólo puede definirse un destructor para cada clase, y que éste nun-ca toma argumentos. Además, el usuario nunca debe ejecutar un destructor de forma explícita.Los destructores son invocados automáticamente por C++ cada vez que un objeto deja de existir.

A continuación, se muestra un programa en el que se crea la clase Caja:

1 # include <iostream >2 # include <cmath >3 using namespace std;45 class Caja{6 private :7 double ancho;8 double largo;9 double alto;

1011 public :12 Caja ();13 Caja( double a, double b, double c);14 double Volumen ();15 double Area ();


16 };1718 Caja :: Caja (){19 ancho =0;20 largo =0;21 alto =0;22 };2324 Caja :: Caja( double a, double b, double c){25 ancho=a;26 largo=b;27 alto=c;28 };2930 Caja :: Volumen (){31 return ancho* largo*alto;32 };3334 Caja :: Area (){35 return 2*( ancho*largo + ancho*alto + largo*alto );36 }3738 int main (){39 Caja M(0.98 , 0.85 , 0.75);40 cout << " Volúmen de la caja: " << M. Volumen () << endl;41 cout << "Area de la caja: " << M.Area () << endl;42 return 0;43 }

8.4. Sobrecarga de operadoresLa sobrecarga de operadores permite que los operadores estándares de C++ puedan progra-marse para operar con los tipos de datos o clases definidas por el usuario. No está permitidoinventar nuevos operadores ni cambiar la precedencia de los existentes. Obviamente, se esperaque el comportamiento de un operador sobrecargado sea consistente con el uso normal que se leda al mismo y razonablemente intuitivo.

La sintaxis para sobrecargar un operador es la siguiente:

<tipo> <Nombre de la clase> operator <#> (lista de parámetros){// instrucciones del operador

}

donde:

tipo de dato: indica el tipo de dato que produce el operador sobrecargado, por lo generales la referencia del objeto.

Nombre de la clase: es el nombre de clase en la que estamos aplicando sobrecarga.

operator: es una palabra reservada utilizada para realizar la sobrecarga

#: operador que estamos sobrecargando.


Lista de parámetros: es la lista de objetos (en referencia) o variables que se procesaránen la sobrecarga, si la operación es unaria no tendrá parámetros, si la operación es binariatendrá un parámetro.

El lenguaje C++ permite redefinir la funcionalidad de los siguientes operadores:

+ - * / % ^ & ~ ! = < > += -= *= /= %= ^= &= |=<< >> >>= <<= == != <= >= && || ++ -- ->* -> [] ()

Los operadores +, −, ∗ y & son sobrecargables en sus dos versiones, unaria y binaria.A continuación, un ejemplo de operadores sobrecargados para la clase Complejo:

Complejo Complejo::operator+ (const Complejo &a){Complejo suma;suma.real = real + a.real;suma.imaginario = imaginario + a.imaginario;return suma;

}

Complejo & Complejo::operator= (const Complejo &a) {real = a.real;imaginario = a.imaginario;return (*this);

}

8.5. Sobrecarga de los operadores de entrada y salidaUn caso especial es la sobrecarga de los operadores << y >> utilizados en la salida y entradade datos respectivamente. Estos operadores se encuentran definidos en la biblioteca iostream deC++.

La sintaxis empleada para la sobrecarga del operador de entrada es la siguiente:

friend istream & operator >> (istream &, <Nombre de la clase> &)

La sintaxis empleada para la sobrecarga del operador de salida es la siguiente:

friend ostream & operator << (ostream &, <Nombre de la clase> &)

Observe que las funciones que se obtienen al sobrecargar los operadores se declaran como amigas(friend) de la clase en la cual se insertaron. Esto es para que dichas funciones, externas a la clase,puedan tener acceso a los miembros privados de la misma.

A continuación, un ejemplo de la sobrecarga del operador de salida para la clase Complejo:

ostream & operator << (ostream & co, const Complejo & a){co << a.real;co << " + ";co << a.imaginario << "i";return co;

}

8.6. Ejercicios1.

Introducción a la Programación en C++ · 2020. 8. 6. · 1 | Introducción a C++ El lenguaje C++...

Documents

Transcript of Introducción a la Programación en C++ · 2020. 8. 6. · 1 | Introducción a C++ El lenguaje C++...