Introducción a la Programación en C++

(1)

Programación en C++

Con ejemplos e ilustraciones

Primera Edición

(2)

Índice general

1. Introducción a C++ 1 1.1. Qué es programar. . . 1 1.2. Lenguaje de programación . . . 2 1.3. Qué es un IDE . . . 3 1.3.1. CodeBlocks . . . 3 1.3.2. Geany . . . 4 1.3.3. Dev C++ . . . 4 1.3.4. OnlineGBD . . . 4 1.4. Instrucciones básicas . . . 4 1.5. Mi primer programa . . . 5

1.5.1. Estructura del código fuente. . . 5

1.6. Comentarios en C++ . . . 6

1.7. Variables . . . 7

1.7.1. Tipos de variables . . . 8

1.8. Entrada y salida de datos . . . 9

1.9. Operadores . . . 9

1.9.1. Operadores aritméticos . . . 10

1.9.2. Operadores de asignación . . . 12

1.10. Constantes . . . 13

1.11. Conversión de tipos. . . 14

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

2.1.1. Expresiones lógicas compuestas . . . 15

2.2. Sentencias condicionales . . . 16 2.2.1. Sentencia if-else. . . 16 2.2.2. Sentencia switch . . . 18 2.3. Sentencias repetitivas . . . 20 2.3.1. Sentencia while . . . 20 2.3.2. Sentencia do - while . . . 22 2.3.3. Sentencia for . . . 24

2.4. Ámbito de las variables . . . 25

3. Datos estructurados 27 3.1. Vectores . . . 27 3.1.1. Inicialización de vectores. . . 29 3.2. Matrices . . . 29 3.2.1. Inicialización de matrices . . . 31 3.3. Arrays . . . 32 3.4. Estructuras . . . 33 3.4.1. Estructuras Anidadas . . . 35

(3)

4.2. Generación de números aleatorios decimales . . . 38

4.3. Evaluación de integrales . . . 39

5. Funciones 42 5.1. Definición de función . . . 42

5.2. Parámetros por defecto . . . 44

5.3. Tipos de datos que devuelve una función. . . 45

5.4. Funciones void . . . 46

5.5. Almacenamiento de variables . . . 47

5.5.1. La Pila . . . 48

5.5.2. Estado de la pila . . . 48

5.6. Funciones recursivas . . . 50

5.7. Paso por variable o referencia . . . 51

5.7.1. Referencias . . . 51

5.7.2. Paso por referencia . . . 53

5.8. Paso de parámetros tipo estructura . . . 56

5.9. Sobrecarga de funciones . . . 57

5.10. Paso de parámetros de tipo vector . . . 58

5.11. Paso de parámetros de tipo array . . . 60

6. Punteros 63 6.1. Qué es un puntero ? . . . 63

6.2. Puntero nulo . . . 64

6.3. Parámetros por referencia . . . 64

6.4. Aritmética de punteros y vectores. . . 66

7. Librería STL 70 7.1. Vectores . . . 70 7.1.1. Iteradores . . . 72 7.2. Matrices . . . 74 8. Clases y Objetos 77 8.1. Definición de clases . . . 78 8.2. Uso de clases . . . 79 8.3. Constructores y destructores . . . 79 8.4. Sobrecarga de operadores . . . 82

8.5. Sobrecarga de los operadores de entrada y salida . . . 83

(4)

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 los lenguajes de programación más utilizados. De hecho muchos de los programas que utilizamos diariamente están hechos en lenguaje C++, por ejemplo: los sistemas operativos Windows, Linux y macOS, los programas de Oﬃce, el sistema Android, entre muchos otros.

1.1. Qué es programar

Programar 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 una manera que pueda entenderlo.

Como ejemplo nos vamos a ubicar sobre un auto de Fórmula 1, si deseamos que el auto acelere esto se lo diremos presionando el acelerador, o si deseamos que disminuya la velocidad esto se lo 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á las instrucciones 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 pueden estar ya integradas en un paquete que instalemos.

(5)

De modo general, programar consiste en dar una serie de instrucciones a la máquina para que esta 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 que quiera realizar una tarea que ya está definida en un programa, sólo tiene que abrirlo y ejecutar.

1.2. Lenguaje de programación

Los lenguajes de programación indican al ordenador qué es lo que este tiene que hacer. Para ello tenemos 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) que

entiende 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 traducir el código fuente a código máquina, si queremos que el ordenador entienda lo que le decimos en el código fuente. Este instrumento es el compilador.

Figura 1.4: Compilador

(6)

1.3. Qué es un IDE

Un IDE, llamado también Entorno de Desarrollo Integrado (IDE son sus siglas en inglés), es un programa o aplicación que consiste en un entorno de trabajo para programar. La aplicación tiene 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 se está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ódigo má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 su descarga 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 operativo que disponga el ordenador, iremos a la sección de Windows, Linux 32, Linux 64, o Mac OS X.

(7)

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 con C++. 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ásicas

El 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 existente para 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 de

(8)

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ódigo

má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 de archivos, como de compilar y ejecutar, y nos centraremos más en el propio lenguaje C++.

1.5. Mi primer programa

En la gran mayoría de los IDEs al momento de crear un nuevo archivo nos encontraremos con el siguiente código: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 co u t < < " Ho l a M u n d o " < < e n d l ; 6 r e t u r n 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ón de 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 siguiente metáfora:

Imaginemos que tener instalado el programa en el computador es como haber adquirido un 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 el rendimiento de ciertos mecanismos ya existentes del auto debido que lo vamos exponien-do a diferentes ambientes y condiciones. Lo anterior pasa exactamente con C++, cuanexponien-do descargamos e instalamos el software contamos con ciertas características y funcionalida-des básicas pero existen varias bibliotecas adicionales que pueden ser agregadas para lograr mejorar su funcionalidad y a la vez realizar cosas estupendas.

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

(9)

using namespace std;

Esta línea declara un namespace o espacio de nombres. En concreto el namespace std o estándar. Dentro del namespace std están declarados todos los elementos de las bibliotecas estándar.

Mediante esta línea podemos usar los elementos de la biblioteca estándar sin necesidad de tener que declararlos cada vez que se usan.

Si no se utiliza la instrucción using namespace std, entonces los nombres cout y endl del có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 de las 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 caso un número entero. La función main siempre devuelve un entero. La segunda palabra es el nombre de la función, en general será el nombre que se usa para realizar el llamado a la función.

cout << Hola Mundo << endl;

Esta sentencia tiene varias partes: En primer lugar cout, que identifica el dispositivo de salida 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 repetimos el operador de inserción (<<) y luego indicamos lo que debe insertarse, en este caso es un salto 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 la ejecución de la función y continuar a partir del punto en que se la llamó. El 0 es el valor de retorno de nuestra función. Cuando main retorna el valor 0 indica que todo ha marchado bien.

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. Los comentarios 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.

(10)

Comentario de línea: Texto que inicia con //. Una vez escritos estos dos caracteres lo

que queda de línea se considera un comentario. 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 // E s t e es un c o m e n t a r i o en l i n e a 6 co u t < < " Mi s e g u n d o p r o g r a m a en C ++ " << e n d l ; 7 /* 8 Es t e es un c o m e n t a r i o en b l o q u e 9 !!! 10 */ 11 12 r e t u r n 0; 13 }

1.7. Variables

Lo contrario de una salida de datos (mensajes en pantalla) es una entrada de datos. En la entrada de 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 para almacenar un texto y un número.

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 // D e f i n i m o s las v a r i a b l e s ... 6 s t r i n g f r a s e = " C o d i g o I n t e r n a c i o n a l T e l e f o n i c o pa r a E c u a d o r "; 7 int n u m e r o = 5 9 3 ; 8 9 // S a l i d a en p a n t a l l a de las v a r i a b l e s ... 10 co u t < < f r a s e < < " : " < < n u m e r o < < e n d l ; 11 12 r e t u r n 0; 13 }

(11)

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, cadena de letras, etc.).

Al dato que se almacena en la variable se le llama valor. Podemos cambiar el valor (el dato que

se 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 espacio en 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 para evaluar 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ígito numérico o un signo de puntuación.

Utiliza generalmente 1 byte de memoria, permite almacenar un carácter, valores; 256 caracteres.

3. unsigned short int: Las variables enteras almacenan números enteros dentro de los límites de su tamaño, a su vez, ese tamaño depende de la plataforma del compilador, y del número de bits que use por palabra de memoria

Utiliza 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 y exponente, 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 # i n c l u d e 2 # i n c l u d e < limits > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n () { 6 co u t < < " M a x i m o e n t e r o : " << n u m e r i c _ l i m i t s <int>:: max () < < e n d l ; 7 co u t < < " M i n i m o e n t e r o : " << n u m e r i c _ l i m i t s <int>:: min () < < e n d l ; 8 co u t < < " M a x i m o f l o a t : " << n u m e r i c _ l i m i t s <float>:: max () < < e n d l ; 9 co u t < < " M i n i m o f l o a t : " << n u m e r i c _ l i m i t s <float>:: min () < < e n d l ; 10

(12)

11 r e t u r n 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 datos

En 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 es la siguiente:

1 co u t < < e x p r e s i o n 1 < < e x p r e s i o n 2 < < ... < < e n d l ;

La instrucción anterior se encarga de convertir el resultado de cada expresión en una cadena de caracteres 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 > > v a r i a b l e 1 > > v a r i a b l e 2 > > ... > > v a r i a b l e n ;

donde: variable 1, variable 2 y variable n son variables. Esta instrucción provoca la lectura de datos desde la entrada estándar, que por defecto está asociada al teclado, y su almacenamiento en 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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 // D e f i n i m o s dos v a r i a b l e s a y b del t i p o d o u b l e 6 d o u b l e a ; 7 d o u b l e b ; 8 // Se i m p r i m e un m e n s a j e al u s u a r i o 9 co u t < < " I n g r e s e dos n u m e r o s " << e n d l ; 10 // Se le e n dos n u m e r o s i n g r e s a d o s a t r a v e s del t e c l a d o 11 cin > > a ; 12 cin > > b ; 13 // Se i m p r i m e un m e n s a j e y la su m a de los dos n u m e r o s 14 co u t < < " La s u m a de los n u m e r o s i n g r e s a d o s es : " << a + b < < e n d l ; 15 16 r e t u r n 0; 17 }

1.9. Operadores

(13)

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 resultado una 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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a =5; 6 co u t < < " N u m e r o p o s i t i v o : " << + a < < e n d l ; 7 co u t < < " N u m e r o n e g a t i v o : " << - a < < e n d l ; 8 9 r e t u r n 0; 10 }

En cuanto a los operadores binarios existen varios: ’+’, ’-’, ’*’ y ’/’, tienen un comportamiento aná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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a , b ; 6 co u t < < " I n g r e s e dos n u m e r o s e n t e r o s p o s i t i v o s : " << e n d l ; 7 cin > > a > > b ; 8 // E m p l e a m o s o p e r a d o r e s b i n a r i o s 9 co u t < < " Su m a : " << a + b < < e n d l ; 10 co u t < < " R e s t a : " << a - b < < e n d l ; 11 co u t < < " M u l t i p l i c a c i o n : " << a * b < < e n d l ; 12 co u t < < " D i v i s i o n : " < < a / b < < e n d l ; 13 14 r e t u r n 0; 15 }

(14)

El operador de módulo %, devuelve el resto de la división entera del primer operando entre el segundo. 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ón

sqrt(x) Raíz cuadrada exp(x) Potencia euleriana

log(x) Logaritmo neperiano log10(x) Logaritmo en base 10

ceil(x) Redondea al entero superior más próximo floor(x) Redondea al entero inferior más cercano

fabs(x) Valor absoluto cos(x) Coseno

sin(x) Seno tan(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 # i n c l u d e 2 # i n c l u d e < cmath > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 int a ; 7 co u t < < " I n g r e s e un n u m e r o p o s i t i v o " < < e n d l ; 8 cin > > a ; 9 10 co u t < < " La r a i z c u a d r a d a es : " << s q r t ( a ) < < e n d l ; 11 co u t < < " El c u b o del n u m e r o es : " << pow ( a ,3) < < e n d l ; 12 co u t < < " L o g a r i t m o n e p e r i a n o : " << log ( a ) < < e n d l ; 13 co u t < < " El r e s t o de d i v i d i r pa r a 2 es : " << a %2 < < e n d l ; 14 15 r e t u r n 0; 16 }

Por último, otros dos operadores unitarios un tanto especiales, ya que sólo pueden trabajar sobre variables, 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 una unidad.

<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 y decremento:

(15)

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a =1 , b =2 , c =3; 6 co u t < < " a ++ : " < < a ++ < < e n d l ; 7 co u t < < " ++ b * 2 : " < < ++ b * 2 < < e n d l ; 8 co u t < < " a : " << a < < " y b : " << b < < e n d l ; 9 co u t < < " b - - : " < < b - - < < e n d l ; 10 co u t < < " ++ c * 3: " << ++ c * 3 < < e n d l ; 11 co u t < < " c ++ : " < < c ++ < < e n d l ; 12 co u t < < " a ++ + -- b + c - - : " << a ++ + - - b + c - - < < e n d l ; 13 14 r e t u r n 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 es la siguiente:

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 una cantidad dada.

A continuación, un programa que emplea varios operadores de asignación: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int a , b , c ; 6 co u t < < " I n g r e s e t r e s n u m e r o s " < < e n d l ; 7 cin > > a > > b > > c ; 8 a += 8; 9 co u t < < " El p r i m e r n u m e r o i n c r e m e n t a d o en 8 u n i d a d e s : " << 10 a < < e n d l ; 11 b *= 3; 12 co u t < < " El t r i p l e del s e g u n d o n u m e r o es : " < < b < < e n d l ; 13 c *= c ; 14 co u t < < " El c u a d r a d o del t e r c e r n u m e r o es : " << c < < e n d l ; 15 16 r e t u r n 0; 17 }

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

(16)

Forma larga Forma corta a = 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. Constantes

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

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

A continuación, un programa que emplea constantes: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 c o n s t d o u b l e IVA = 0 . 1 2 ; 6 c o n s t d o u b l e P R O P I N A = 0 . 0 5 ; 7 d o u b l e p r e c i o ; 8 co u t < < " I n g r e s e el v a l o r del c o n s u m o " << e n d l ; 9 cin > > p r e c i o ; 10 p r e c i o

11 co u t < < " Su f a c t u r a con IVA es de : " << p r e c i o + p r e c i o * IVA 12 < < " d o l a r e s " < < e n d l ; 13 co u t < < " Su f a c t u r a i n c l u i d a la p r o p i n a es de : " 14 < < p r e c i o + p r e c i o * ( IVA + P R O P I N A ) < < " d o l a r e s " 15 < < e n d l ; 16 co u t < < " G r a c i a s por su c o n s u m o " << e n d l ; 17 18 r e t u r n 0; 19 }

(17)

1.11. Conversión de tipos

Cuando se realizan operaciones aritméticas con operandos de distinto tipo, C++ realiza una conversión implícita del operando cuyo tipo tiene un rango de representación menor al tipo del operando 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 convierte implícitamente a real, realizándose la operación entre reales.

A continuación, un programa que ejemplifica la conversión de tipos: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int a = 32 , 6 d o u b l e b = 1 0 . 5 ; 7 // S u m a de e n t e r o y re a l 8 co u t < < a + b < < e n d l : 9 // D i v i s i o n de e n t e r o a e n t e r o 10 co u t < < a /5 < < e n d l ; 11 // D i v i s i o n e n t e r o a r e a l 12 co u t < < a / 5 . 0 < < e n d l : 13 // C o n v e r s i o n e x p l i c i t a 14 co u t < < (f l o a t) a /5 < < e n d l ; 15 16 r e t u r n 0; 17 }

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

(tipo) operando

(18)

2 |

Sentencias condicionales y

repe-titivas

2.1. Expresiones lógicas

Una expresión lógica es aquella que produce un resultado de verdadero o falso. Se puede construir una 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 operadores relacionales 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 usuario son iguales: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a , b ; 6 bo o l res ; 7 co u t < < " I n g r e s e dos n u m e r o s e n t e r o s " << e n d l ; 8 cin > > a > > b ; 9 10 // E x p r e s i o n l o g i c a s i m p l e 11 res = a == b ; 12 co u t < < " R e s u l t a d o : " << res < < e n d l ; 13 14 r e t u r n 0; 15 }

2.1.1. Expresiones lógicas compuestas

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

(19)

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 e identificar 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 iguales y pares a la vez: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a , b ; 6 bo o l res ; 7 co u t < < " I n g r e s e dos n u m e r o s e n t e r o s " << e n d l ; 8 cin > > a > > b ; 9 10 // E x p r e s i o n l o g i c a c o m p u e s t a 11 res = ( a == b ) && ( a %2 == 0); 12 co u t < < " R e s u l t a d o : " << res < < e n d l ; 13 14 r e t u r n 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 condicionales

Las sentencias condicionales permiten seleccionar qué codigo ejecutar en función del resultado de 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 resultado de 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 }

(20)

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 de instrucciones 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 o indentados), pues esto aumenta la legibilidad del programa.

A continuación, un ejemplo que permite identificar si el número entero ingresado por el usuario es par o impar: 1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int a ; 6 co u t < < " I n g r e s e un n u m e r o e n t e r o " < < e n d l ; 7 cin > > a ; 8 9 // S e n t e n c i a c o n d i c i o n a l 10 if(( a % 2) == 0){ 11 c o u t < < " El n u m e r o i n g r e s a d o es par " < < e n d l ; 12 } el s e { 13 c o u t < < " El n u m e r o i n g r e s a d o es i m p a r " < < e n d l ; 14 } 15 r e t u r n 0; 16 }

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

x1,2 = −b ± √

b2_{− 4ac}

2a

(21)

1 # i n c l u d e 2 # i n c l u d e < cmath > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 d o u b l e a , b , c , d ; 7 co u t < < " R a i c e s del p o l i n o m i o : ax ^2 + bx + c = 0 " < < e n d l ; 8 co u t < < " I n g r e s e los c o e f i c i e n t e s : " << e n d l ; 9 cin > > a > > b > > c ; 10 11 // C a l c u l o del d i s c r i m i n a n t e 12 d = pow ( b ,2) - 4* a * c ; 13 14 // S e n t e n c i a c o n d i c i o n a l 15 if( d < 0){ 16 co u t < < " El p o l i n o m i o no t i e n e r a i c e s r e a l e s " < < e n d l ; 17 } e l s e if( d == 0) { 18 co u t < < " Las r a i c e s son i g u a l e s a : " 19 < < (f l o a t) - b / ( 2 * a ) < < e n d l ; 20 } e l s e { 21 co u t < < " La p r i m e r a ra i z es : " 22 < < (f l o a t) ( - b - pow ( d , 0 . 5 ) ) / ( 2 * a ) < < e n d l ; 23 co u t < < " La s e g u n d a ra i z es : " 24 < < (f l o a t) ( - b + pow ( d , 0 . 5 ) ) / ( 2 * a ) < < e n d l ; 25 } 26 r e t u r n 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:

(22)

switch (expresion){ case literal1: bloque de instrucciones 1 break; case literal2: bloque de instrucciones 2 break; ... case literaln: bloque de instrucciones n break; default:

bloque de instrucciones por defecto break;

}

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

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 co u t < < " I n g r e s e la o p c i o n a e j e c u t a r : " < < e n d l ; 6 ch a r o p c i o n ; 7 cin > > o p c i o n ; 8 9 s w i t c h( o p c i o n ){ 10 ca s e ’ a ’: 11 co u t < < " Ha s e l e c c i o n a d o la o p c i o n a " << e n d l ; 12 b r e a k; 13 ca s e ’ b ’: 14 co u t < < " Ha s e l e c c i o n a d o la o p c i o n b " << e n d l ; 15 b r e a k; 16 ca s e ’ c ’: 17 co u t < < " Ha s e l e c c i o n a d o la o p c i o n c " << e n d l ; 18 b r e a k; 19 d e f a u l t: 20 co u t < < " Ha i n g r e s a d o una o p c i o n i n c o r r e c t a " < < e n d l ; 21 } 22 23 r e t u r n 0; 24 }

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

(23)

kilo-1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int x ; 6 f l o a t p u l g a d a s , kilo , d i s t a n c i a , p e s o ; 7 co u t < < " Que d e s e a c o n v e r t i r , d i s t a n c i a o pe s o ? " < < e n d l ; 8 co u t < < " E s c r i b a 1 pa r a d i s t a n c i a o 2 pa r a pe s o " < < e n d l ; 9 cin > > x ; 10 11 s w i t c h ( x ){ 12 ca s e 1: 13 co u t < < " I n g r e s e la d i s t a n c i a en c e n t i m e t r o s : " < < e n d l ; 14 cin > > d i s t a n c i a ; 15 p u l g a d a s = d i s t a n c i a / 2 . 5 4 ; 16 co u t < < " Las p u l g a d a s son : " < > p e s o ; 21 ki l o = p e s o * (1 / 2 . 2 1 ) ; 22 co u t < < " Los k i l o g r a m o s son : " < < k i l o < < e n d l ; 23 b r e a k; 24 d e f a u l t: 25 co u t < < " O p c i o n no v a l i d a " < < e n d l ; 26 } 27 28 r e t u r n 0; 29 }

2.3. Sentencias repetitivas

Las sentencias repetitivas o iterativas, también llamadas ciclos o bucles, permiten ejecutar un conjunto 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 sea verdadera.

(24)

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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int n u m e r o ; 6 co u t < < " I n g r e s e un n u m e r o e n t e r o " < < e n d l ; 7 cin > > n u m e r o ; 8 9 // S e n t e n c i a r e p e t i t i v a 10 w h i l e( n u m e r o <= 1 0 ) { 11 co u t < < " I n g r e s e o t r o n u m e r o : "; 12 cin > > n u m e r o ; 13 } 14 r e t u r n 0; 15 }

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

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int num , s u m a ; 6 7 co u t < < " - - - P r o g r a m a S u m a - - - " < < e n d l ; 8 num = 0; 9 su m a = 0; 10 11 w h i l e ( num != 9 9 9 ) { 12 s u m a += num ; 13 c o u t < < " I n g r e s a un n u m e r o ( t e c l e a 999 p a r a t e r m i n a r ): " 14 < < e n d l ; 15 cin > > num ; 16 } 17 co u t < < " La s u m a t o t a l es : " << s u m a < < e n d l ; 18 19 r e t u r n 0; 20 }

(25)

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

a 1− x− n ∑ i=0 axi < 10−7 1 # i n c l u d e 2 # i n c l u d e < cmath > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n () { 6 d o u b l e a , x ; 7 c o n s t d o u b l e E R R O R = pow (10 , -7); 8 co u t < < " I n g r e s e los v a l o r e s de a y x : " < < e n d l ; 9 cin > > a > > x ; 10 11 // S e n t e n c i a c o n d i c i o n a l s o b r e x 12 if( x > -1 && x < 1){ 13 d o u b l e sum = 0; 14 int i = 0; 15 // S e n t e n c i a r e p e t i t i v a p a r a h a l l a r el v a l o r de n 16 w h i l e( a /(1 - x ) - sum > E R R O R ){ 17 sum += a * pow ( x , i ); 18 i ++; 19 } 20 c o u t < < " El v a l o r de n b u s c a d o es : " < < i -1 < < e n d l ; 21 } el s e { 22 c o u t < < " El v a l o r de x no es v a l i d o " < < e n d l ; 23 } 24 25 r e t u r n 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 sentensenten-cia do-while el conjunto de instrucciones se ejecutará por lo menos una vez.

(26)

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 de la evaluación es verdadero se vuelve a ejecutar el conjunto de instrucciones, así hasta que la expresió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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int o p c i o n ; 6 f l o a t centi , f a h r e ; 7 bo o l t e r m i n a r = f a l s e; 8 co u t < < " - - - C o n v e r s i o n de t e m p e r a t u r a s - - - " << e n d l ; 9 10 do { 11 co u t < < " E s c o j a una o p c i o n : " < < e n d l ; 12 co u t < < " 1. C o n v e r t i r G r a d o s c e n t i g r a d o s a F a h r e n h e i t : " 13 << e n d l ; 14 co u t < < " 2. C o n v e r t i r G r a d o s F a h r e n h e i t a C e n t i g r a d o s : " 15 << e n d l ; 16 co u t < < " 3. S a l i r del p r o g r a m a " < < e n d l ; 17 cin > > o p c i o n ; 18 19 s w i t c h ( o p c i o n ){ 20 c a s e 1: 21 c o u t < < " I n g r e s e los g r a d o s c e n t i g r a d o s : " < < e n d l ; 22 cin > > c e n t i ; 23 f a h r e = ( c e n t i * 1 . 8 ) + 32; 24 c o u t < < " Su e q u i v a l e n t e en f a h r e n h e i t es : " 25 < < f a h r e < < e n d l ; 26 b r e a k; 27 c a s e 2: 28 c o u t < < " I n g r e s e los g r a d o s f a h r e n h e i t : " < < e n d l ; 29 cin > > f a h r e ; 30 c e n t i = ( f a h r e - 3 2 ) / 1 . 8 ; 31 c o u t < < " Su e q u i v a l e n t e en c e n t i g r a d o s es : " 32 < < c e n t i < < e n d l ; 33 b r e a k; 34 d e f a u l t: 35 c o u t < < " G r a c i a s por us a r el p r o g r a m a " < < e n d l ; 36 t e r m i n a r = t r u e; 37 } 38 } w h i l e (! t e r m i n a r ); 39 40 r e t u r n 0; 41 }

(27)

2.3.3. Sentencia for

La sentencia for está pensada principalmente para expresar ciclos que se ejecutan un número fijo de veces. La sentencia for resulta más legible que las sentencias while y do while, pues permite expresar la iniciación, incremento y condición lógica asociada a la variable que controla el ciclo en 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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n () { 5 int numero , f a c t = 1; 6 co u t < < " I n t r o d u z c a un e n t e r o p o s i t i v o : " << e n d l ; 7 cin > > n u m e r o ; 8 for (int i = 1; i <= n u m e r o ; i + + ) { 9 f a c t *= i ; 10 } 11 co u t < < " El f a c t o r i a l de " < < n u m e r o < < " es " << f a c t < < e n d l ; 12 r e t u r n 0; 13 }

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

(28)

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int numero , i ; 6 bo o l p r i m o = f a l s e; 7 8 co u t < < " I n g r e s e un e n t e r o p o s i t i v o (0 p a r a t e r m i n a r ): " 9 < < e n d l ; 10 cin > > n u m e r o ; 11 12 w h i l e( n u m e r o != 0){ 13 for( i = 2; i < n u m e r o ; i + + ) { 14 if( n u m e r o % i == 0) 15 p r i m o = t r u e; 16 } 17 if( p r i m o ){ 18 c o u t < < " El n u m e r o " << n u m e r o < < " no es p r i m o " 19 < < e n d l ; 20 } e l s e { 21 c o u t < < " El n u m e r o " << n u m e r o < < " es p r i m o " < < e n d l ; 22 } 23 co u t < < " I n g r e s e s un e n t e r o p o s i t i v o (0 p a r a t e r m i n a r ): "; 24 cin > > n u m e r o ; 25 p r i m o = f a l s e; 26 } 27 28 r e t u r n 0; 29 }

2.4. Ámbito de las variables

C++ 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 programa en la que puede ser usada. A continuación, se enumeran las principales reglas sobre el lugar de definició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 bloque más interno en que se ha definido la variable (un bloque es un conjunto de instrucciones

encerradas 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 no solapados o en bloques solapados de distinto nivel de profundidad.

(29)

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int z =3; 6 int x =8; 7 8 if(t r u e){ 9 int x = 0; 10 c o u t < < x < < e n d l ; 11 } 12 13 for(int x = 1; x < 11; x + + ) { 14 c o u t < < x < < e n d l ; 15 } 16 co u t < < x < < e n d l ; 17 18 if(t r u e){ 19 int z =4; 20 c o u t < < z < < e n d l ; 21 } 22 co u t < < z < < e n d l ; 23 24 r e t u r n 0; 25 }

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

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

3.000.000 = 3.0e6 0.0000567 = 5.67e-5

(30)

3 |

Datos estructurados

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

3.1. Vectores

Un vector es una estructura unidimensional que almacena una secuencia de datos del mismo tipo. Los elementos de un vector se almacenan en zonas contiguas de memoria y se puede acceder a 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 sirve para 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; // Variable

cout << "Ingrese un entero" << endl; cin >> x;

(31)

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 que indica 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 almacenados en 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 la suma vectorial y el producto interno:

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 f l o a t v e c t o r 1 [ 3 ] ; 6 f l o a t v e c t o r 2 [ 3 ] ; 7 f l o a t S u m a [ 3 ] ; 8 f l o a t P r o d u c t o = 0; 9 // D a t o s del p r i m e r v e c t o r 10 for(int i =0; i <3; i + + ) { 11 co u t < < " I n t r o d u c e la c o m p o n e n t e " < > v e c t o r 1 [ i ]; 14 } 15 // D a t o s del s e g u n d o v e c t o r 16 for(int i =0; i <3; i + + ) { 17 co u t < < " I n t r o d u c e la c o m p o n e n t e " < > v e c t o r 2 [ i ]; 20 } 21 // S u m a de v e c t o r e s 22 for(int i =0; i <3; i + + ) { 23 Su m a [ i ] = v e c t o r 1 [ i ] + v e c t o r 2 [ i ]; 24 } 25 // P r o d u c t o i n t e r n o 26 for(int i =0; i <3; i + + ) { 27 P r o d u c t o += v e c t o r 1 [ i ] * v e c t o r 2 [ i ]; 28 } 29 // M o s t r a m o s el r e s u l t a d o 30 co u t < < " El v e c t o r su m a es "; 31 for (int i =0; i <3; i ++) 32 co u t < < S u m a [ i ] < < " "; 33 co u t < < e n d l ; 34 35 co u t < < " El p r o d u c t o i n t e r n o es : " < < P r o d u c t o < < e n d l ; 36 37 r e t u r n 0; 38 }

(32)

3.1.1. Inicialización de vectores

Se puede inicializar un vector en la misma definición de la variable. Para realizar esto hay que encerrar 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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int g a s t o s [6] = {200 , 150 , 100 , 250 , 300 , 2 8 5 } ; 6 int su m a ; 7 8 su m a = 0; 9 for (int i =0; i < = 4 ; i + + ) { 10 su m a += g a s t o s [ i ]; 11 }; 12 13 co u t < < " El g a s t o t o t a l es : " < < s u m a ; 14 15 r e t u r n 0; 16 }

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

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int d i a s M e s [] = {31 , 28 , 31 , 30 , 31 , 30 , 6 31 , 31 , 30 , 31 , 30 , 3 1 } ; 7 8 s t r i n g Mes [] = {" E n e r o ", " F e b r e r o ", " M a r z o ", " A b r i l ", " M a y o ", 9 " J u n i o ", " J u l i o ", " A g o s t o ", " S e p t i e m b r e ", " O c t u b r e ", 10 " N o v i e m b r e ", " D i c i e m b r e "}; 11 12 for(int i =0; i < 1 2 ; i + + ) { 13 co u t < < " El mes de " < < Mes [ i ] < < " t i e n e " < < d i a s M e s [ i ] 14 < < " d i a s " << e n d l ; 15 }; 16 17 r e t u r n 0; 18 }

3.2. Matrices

Una matriz es una estructura bidimensional que almacena una secuencia de datos del mismo tipo en filas y columnas. Los elementos de una matriz se almacenan en zonas contiguas de memoria

(33)

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 al nombre de la estructura matriz, filas y columnas son expresiones enteras que indican el número de 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 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 d o u b l e m a t r i z 1 [ 2 ] [ 2 ] ; 6 d o u b l e m a t r i z 2 [ 2 ] [ 2 ] ; 7 d o u b l e S u m a [ 2 ] [ 2 ] ; 8 9 // I n g r e s o v a l o r e s m a t r i z 1 10 co u t < < " M a t r i z 1 " << e n d l ; 11 for(int i =0; i <2; i + + ) { 12 for(int j =0; j <2; j + + ) { 13 c o u t < < " I n g r e s e el e l e m e n t o " < > m a t r i z 1 [ i ][ j ]; 15 } 16 } 17 18 // I n g r e s o v a l o r e s m a t r i z 2 19 co u t < < " M a t r i z 2 " << e n d l ; 20 for(int i =0; i <2; i + + ) { 21 for(int j =0; j <2; j + + ) { 22 c o u t < < " I n g r e s e el e l e m e n t o " < > m a t r i z 2 [ i ][ j ]; 24 } 25 } 26 27 // S u m a de m a t r i c e s 28 for(int i =0; i <2; i + + ) { 29 for(int j =0; j <2; j + + ) { 30 S u m a [ i ][ j ] = m a t r i z 1 [ i ][ j ] + m a t r i z 2 [ i ][ j ]; 31 }

(34)

32 } 33 34 // R e s u l t a d o 35 co u t < < " El r e s u l t a d o es : " << e n d l ; 36 for(int i =0; i <2; i + + ) { 37 for(int j =0; j <2; j + + ) { 38 c o u t < < S u m a [ i ][ j ] < < " "; 39 } 40 co u t < < e n d l ; 41 } 42 r e t u r n 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 que encerrar entre llaves la lista de valores de cada fila con que se inicia la matriz, separando los valores entre sí mediante comas.

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

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int N o t a s [ ] [ 1 0 ] = {{17 , 20 , 13 , 14 , 15 , 19 , 17 , 18 , 19 , 10} , 6 {18 , 12 , 19 , 14 , 15 , 16 , 17 , 13 , 19 , 20 }}; 7 8 // P r o m e d i o por c u r s o 9 d o u b l e p r o m 1 =0 , p r o m 2 =0; 10 for(int i =0; i < 1 0 ; i + + ) { 11 p r o m 1 += 0 . 1 * N o t a s [ 0 ] [ i ]; 12 p r o m 2 += 0 . 1 * N o t a s [ 1 ] [ i ]; 13 } 14 15 // C o m p a r a c i o n p r o m e d i o s 16 if( p r o m 1 > p r o m 2 ){ 17 co u t < < " El p r i m e r c u r s o t i e n e m e j o r p r o m e d i o " << e n d l ; 18 } e l s e if( p r o m 1 < p r o m 2 ){ 19 co u t < < " El s e g u n d o c u r s o t i e n e m e j o r p r o m e d i o " << e n d l ; 20 } e l s e { 21 co u t < < " A m b o s c u r s o s t i e n e n i g u a l p r o m e d i o " < < e n d l ; 22 } 23 24 r e t u r n 0; 25 }

(35)

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

3.3. Arrays

C++ 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 los tamaños de las distintas dimensiones del array.

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

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 int ma i n (){ 5 int V e n t a s [ 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 , 3 4 } ; 8 9 // V i s t a A r r a y 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 c o u t < < V e n t a s [ i ][ j ][ k ] < < " "; 14 } 15 c o u t < < e n d l ; 16 } 17 co u t < < e n d l ; 18 co u t < < e n d l ; 19 }; 20 21 // T o t a l V e n t a s por p r o d u c t o

22 int TP r o [ 4 ] ; // V e c t o r que a l m a c e n a los t o t a l e s

23 for(int i =0; i <4; i + + ) {

(36)

25 for(int j =0; j <3; j + + ) { 26 for(int k =0; k <2; k + + ) { 27 T P r o [ i ] += V e n t a s [ i ][ j ][ k ]; 28 } 29 } 30 }; 31 32 // R e s u l t a d o s por p r o d u c t o 33 for(int i =0; i <4; i + + ) { 34 c o u t < < " T o t a l P r o d u c t o " << i +1 < < " : " < < T P r o [ i ] < < e n d l ; 35 } 36 37 r e t u r n 0; 38 }

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

3.4. Estructuras

C++ 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 una colección de datos de tipos existentes ya sean tipos básicos o estructurados como arrays, cadenas de caracteres o estructuras ya definidas. Las estructuras son muy útiles pues permiten definir tipos de datos que se ajustan con exactitud a las necesidades de representación de cualquier objeto. Con una estructura se puede representar un alumno, un seguro, un vehículo, etc.

Rojo Toyota Modelo 2018 230 CV Verde Ford Modelo 2016 280 CV Azul Mercedes Benz Modelo 2020 350 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; };

(37)

datos que componen el nuevo tipo. A cada uno de los datos se le llama campo o miembro. La definición de cada campo tiene la estructura de la definición de una variable, es decir, en primer lugar 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 nueva estructura y obtiene la edad promedio:

1 # i n c l u d e 2 u s i n g n a m e s p a c e std ; 3 4 // D e f i n i c i o n n u e v a e s t r u c t u r a 5 s t r u c t p e r s o n a { 6 ch a r n o m b r e [ 1 5 ] ; 7 int e d a d ; 8 ch a r se x o [ 1 5 ] ; 9 int t e l e f o n o ; 10 }; 11 12 int ma i n (){ 13 p e r s o n a a m i g o [ 5 ] ; 14 // I n g r e s o de i n f o r m a c i o n 15 for(int i = 0; i < 5; i + + ) { 16 co u t < < " E s c r i b a el N o m b r e " < > a m i g o [ i ]. n o m b r e ; 18 co u t < < " \ n E s c r i b a la E d a d de " < > a m i g o [ i ]. e d a d ; 20 co u t < < " \ n E s c r i b a el s e x o " < > a m i g o [ i ]. s e x o ; 22 co u t < < " \ n E s c r i b a el T e l e f o n o de " < > a m i g o [ i ]. t e l e f o n o ; 24 co u t < < e n d l ; 25 }; 26 27 // I m p r e s i o n r e g i s t r o s 28 co u t < < " El r e g i s t r o de p e r s o n a s que se i n t r o d u j e r o n es :\ n \ n "; 29 for (int i = 0; i < 5; i + + ) { 30 co u t < < " \ t " < < a m i g o [ i ]. n o m b r e ; 31 co u t < < " \ t " < < a m i g o [ i ]. e d a d ; 32 co u t < < " \ t " < < a m i g o [ i ]. s e x o ; 33 co u t < < " \ t " < < a m i g o [ i ]. t e l e f o n o < < " \ n \ n "; 34 }; 35 36 // E d a d p r o m e d i o 37 d o u b l e E P r o m = 0; 38 for (int i = 0; i < 5; i + + ) { 39 E P r o m += 0 . 2 * a m i g o [ i ]. e d a d ; 40 }; 41 42 co u t < < " La e d a d p r o m e d i o es : " << E P r o m < < e n d l ; 43 44 r e t u r n 0; 45 }

(38)

3.4.1. Estructuras Anidadas

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

A continuación, un ejemplo en el que se emplea una estructura anidada: 1 # i n c l u d e

2 # i n c l u d e < string >

3 u s i n g n a m e s p a c e std ; 4

5 s t r u c t F e c h a N a c {

6 int anio , mes , dia ; 7 }; 8 9 s t r u c t e s t u d i a n t e { 10 s t r i n g nombre , g e n e r o ; 11 F e c h a N a c f e c h a ; 12 }; 13 14 int ma i n (){ 15 e s t u d i a n t e E1 = {" Lu i s ", " M a s c u l i n o " , {1997 , 10 , 2 9 } } ; 16 17 co u t < < " N o m b r e del e s t u d i a n t e : " < < E1 . n o m b r e < < e n d l ; 18 co u t < < " G e n e r o : " < < E1 . g e n e r o < < e n d l ; 19 co u t < < " F e c h a de n a c i m i e n t o : " << E1 . f e c h a . dia < < " / " 20 << E1 . f e c h a . mes < < " / " << E1 . f e c h a . a n i o < < e n d l ; 21 r e t u r n 0; 22 }

(39)

Una característica importante en la gran mayoría de lenguajes de programación es la posibilidad de 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úmeros aleatorios para automatizar el proceso de llenado de arreglos y más.

4.1. Generación de números aleatorios enteros

Uno de los métodos más comunes para generar números aleatorios, llamado método

congruen-cial multiplicativo, comienza con un valor inicongruen-cial x0, llamado semilla, y luego se calcula de

manera recursiva los valores sucesivos xn, n≥ 1, haciendo:

xn= axn−1 m´od m

donde a y m son enteros positivos dados y lo anterior significa que axn−1 se divide entre m y el

residuo 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 el

intervalo (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úmero entero 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 sises-tema operativo. A continuación, se muestra un programa que genera y almacena 20 números enteros aleatorios entre 0 y RAND_MAX:

(40)

1 # i n c l u d e 2 # i n c l u d e < cstdlib > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 int vec [ 2 0 ] ; 7 8 // G e n e r a m o s v a l o r e s e n t r e 0 y R A N D _ M A X 9 for(int i =0; i < 2 0 ; i + + ) { 10 vec [ i ] = r a n d (); 11 co u t < < vec [ i ] < < " "; 12 } 13 14 // L i m i t e s u p e r i o r p e r m i t i d o por el e q u i p o 15 co u t < < " \ n El R A N D _ M A X pa r a es t e e q u i p o es : " << R A N D _ M A X ; 16 17 r e t u r n 0; 18 }

Si ejecutamos varias veces el programa anterior se puede observar que los números obtenidos en cada ejecución coinciden. Esto se debe principalmente a que la semilla es exactamente la misma en cada ejecución. Para solventar este problema se recomienda resetear la semilla en cada 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 y hora 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 # i n c l u d e 2 # i n c l u d e < cstdlib > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 int vec [ 5 ] ; 7 8 // S e m i l l a a l e a t o r i a 9 s r a n d ( t i m e ( N U L L )); 10 11 // G e n e r a m o s v a l o r e s e n t r e 0 y R A N D _ M A X 12 for(int i =0; i <5; i + + ) { 13 vec [ i ] = r a n d (); 14 co u t < < vec [ i ] < < " "; 15 }; 16 17 r e t u r n 0; 18 }

(41)

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 del módulo ( %):

rand() % (Limite superior + 1)

A continuación, un programa que genera 100 números aleatorios entre [0, 20] y obtiene la suma de dichos números: 1 # i n c l u d e 2 # i n c l u d e < cstdlib > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 int vec [ 1 0 0 ] ; 7 8 // S e m i l l a a l e a t o r i a 9 s r a n d ( t i m e ( N U L L )); 10 11 // V a l o r e s a l e a t o r i o s 12 co u t < < " Los v a l o r e s g e n e r a d o s son : " < < e n d l ; 13 for(int i =0; i < 1 0 0 ; i + + ) { 14 vec [ i ] = r a n d () % 21; 15 }; 16 17 // C a l c u l o s u m a 18 int su m a = 0; 19 for(int i =0; i < 1 0 0 ; i + + ) { 20 co u t < < vec [ i ] < < e n d l ; 21 su m a += vec [ i ]; 22 }; 23 24 co u t < < " La s u m a de los v a l o r e s g e n e r a d o s : " << e n d l ; 25 co u t < < s u m a < < e n d l ; 26 27 r e t u r n 0; 28 }

4.2. Generación de números aleatorios decimales

Ahora nos centraremos en la generación de números aleatorios decimales, para ello basta recordar que el número pseudoaleatorio yn =

xn

m se 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 en el intervalo [1, 4].

(42)

1 # i n c l u d e 2 # i n c l u d e < cstdlib > 3 u s i n g n a m e s p a c e std ; 4 5 int ma i n (){ 6 d o u b l e vec [ 1 0 ] ; 7 8 // S e m i l l a a l e a t o r i a 9 s r a n d ( t i m e ( N U L L )); 10 11 // G e n e r a m o s v a l o r e s e n t r e 0 y R A N D _ M A X 12 for(int i =0; i < 1 0 ; i + + ) { 13 vec [ i ] = 1 + (d o u b l e) ( r a n d () % 3 0 0 0 1 ) / 1 0 0 0 0 ; 14 co u t < < vec [ i ] < < " "; 15 }; 16 17 r e t u r n 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:

θ = ∫ ₁

0

g(x)dx

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

θ = E[g(U )]

Si U1, U2, . . . , Uk son variables aleatorias independientes y uniformes en (0, 1), esto implica que

g(U1), g(U2), . . . , g(Uk) son variables aleatorias independientes e idénticamente distribuidas con

media θ.

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 uiy

con-siderando como nuestra aproximación a θ el valor medio de g(ui). Este método de aproximación

de integrales es conocido como el método de Monte Carlo.

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

θ = ∫ 1

0

ex− 1 e− 1 dx

(43)

1 # i n c l u d e 2 # i n c l u d e < cmath > 3 # i n c l u d e < cstdlib > 4 u s i n g n a m e s p a c e std ; 5 6 int ma i n (){ 7 int k ; 8 d o u b l e u , sum =0; 9 10 co u t < < " I n g r e s e el v a l o r k " << e n d l ; 11 cin > > k ; 12 13 // S e m i l l a a l e a t o r i a 14 s r a n d ( t i m e ( N U L L )); 15 16 // C a l c u l o de la i n t e g r a l 17 for(int i =0; i < k ; i + + ) { 18 u = (d o u b l e) (1 + r a n d () % 1 0 0 0 0 ) / 1 0 0 0 0 ; 19 sum += (d o u b l e) ( exp ( u ) -1)/( exp (1) -1);

20 }; 21 22 // I m p r e s i o n r e s u l t a d o 23 co u t < < " V a l o r i n t e g r a l : " << (d o u b l e) sum / k < < e n d l ; 24 25 r e t u r n 0; 26 }

Si quisiéramos calcular la integral:

θ = ∫ _b

a

g(x)dx

entonces, al hacer la sustitución:

y = x− a b− a y dy = dx b− a vemos que: θ = ∫ ₁ 0 g (a + [b− a]y) (b − a)dy = ∫ ₁ 0 h(y)dy

donde h(y) = (b− a)g (a + [b − a]y). Así, podemos aproximar θ al generar de manera continua nú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