Introducción a C++

Los fundamentos del lenguaje

 Introducción a C++
Los fundamentos del lenguaje

El lenguaje C++ es uno de los lenguajes más exitosos y utilizados actualmente. Muchos otros
lenguajes como Java, C#, Objective C están basados en su sintaxis y potencia. C++ es un
lenguaje de programación basado en el lenguaje C, originalmente desarrollado por
Dennis Ritchie entre 1969 y 1972 en los Laboratorios Bell. C++ es un lenguaje de
programación diseñado por Bjarne Stroustrup con la intención de añadirle a C la
programación orientada a objetos. Este curso está orientado a los programadores que deseen
introducirse en los principios del lenguaje C++. Nuestros objetivos son:
Para tomar este curso debes tener una computadora con Windows 7 o superior, conexión a
internet y un editor de código como SublimeText, Brackets, Dreamweaver, etc.
● Aprender los tipos de datos y el uso de variables en C++
● Crear diferentes tipos de expresiones utilizando operadores, operandos y literales.
● Aprender las diferentes estructuras condicionales dentro del lenguaje C++
● Aplicar las estructura cíclica como do..while, while y for, así como el operador condicional.
● Aprender a crear, llamar y pasar parámetros por valor o por referencia.
● Aprender las funciones estándar de las librerías ANSI C
● Aprender a crear y poblar estructuras y a utilizar los apuntadores en el Lenguaje C++
● Crear y modificar los apuntadores o punteros en el lenguaje C++
● Crear las clases y sus constructores en la programación orientada a objetos en el lenguaje C++
● Poder crear funciones amigas, funciones amigas en otras clases, crear clases amigas, crear y usar getters y
setters, crear funciones en línea, funciones constantes.
● Crear clases derivadas con constructores, crear destructores de la jerarquía de clases, funciones que se
relacionen entre clases heredadas, sobreescribir funciones en las clases heredadas.
● Crear funciones y clases por medio de plantillas.

Para tomar este curso debes tener una computadora con Windows 7 o superior, conexión a
internet y un editor de código como SublimeText, Brackets, Dreamweaver, etc.
 Introducción a C++
Los fundamentos del lenguaje
Capítulo 1: Introducción a C++
Objetivo: El alumno aprenderá los tipos de datos y el uso de variables en C++

Introducción:
El lenguaje C++ es uno de los más poderosos y más utilizados para el desarrollo de
aplicaciones de todo tipo.
 Introducción a C++

1.1. Introducción a C++

C es un lenguaje de programación originalmente desarrollado por Dennis Ritchie entre 1969 y
1972 en los Laboratorios Bell,? como evolución del anterior lenguaje B, a su vez basado en
BCPL.
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención de
su creación fue el extender al lenguaje de programación C con mecanismos que permiten la
manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a
objetos, el C++ es un lenguaje híbrido.
Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de
los fabricantes de compiladores más modernos.

Imagen 1.1.1. Bjarne-Stroustrup tomo el lenguaje C y le implemento la programacion orientada a objetos.

Autor: Francisco J. Arce A. página 4/180 [Link]

 Introducción a C++

1.2. Instalar el compilador en Windows 7

● Instalar minGW
● Configurar variables de entorno
● inicio
● panel
● sistema y seguridad
● sistema
● configuración avanzada del sistema
● variables de entorno
● path
● c:\MinGw\bin
● Compilar desde la consola

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 cout<< "Hola mundo" <<endl;
6 return 0;
7 }
Listado 1.2.1. [Link]

Autor: Francisco J. Arce A. página 5/180 [Link]

 Introducción a C++

1.3. Instalar el compilador en Windows 10

● Instalar minGW
● Configurar variables de entorno
● Compilar desde la consola

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 cout<< "Hola mundo" <<endl;
6 return 0;
7 }
Listado 1.3.1. [Link]

Autor: Francisco J. Arce A. página 6/180 [Link]

 Introducción a C++

1.4. Estructura de un programa

● Con endl se entiende “fin de línea” (end line) y es equivalente a “\n”.
● Los datos se envían al “canal” de salida utilizando el operador <<.
● La biblioteca <iostream> tiene istream para las entrada y ostream para las salidas.
● Los procesos de entrada/salida (input/output) se encuentran en el archivo de cabecera <iostream>.
● Los archivos como <iostream> se llaman archivos de cabecera o bibliotecas.
● Las directivas del preprocesador: Los archivos llamados por la directiva #include, el preprocesador “pega” el
archivo antes de iniciar la compilación.

1 //[Link]
2 #include <iostream>
3
4 int main(){
5 std::cout<< "Escribe dos numeros" << std::endl;
6 int n1,n2;
7 std::cin >>n1 >> n2;
8 std::cout<< "la suma es " << n1 << "+" <<n2
9 << "es" << n1+n2 <<std:: endl;
10 return 0;
11 }
Listado 1.4.1. [Link]

Autor: Francisco J. Arce A. página 7/180 [Link]

 Introducción a C++

1.5. Los espacios de nombres

Los espacios de nombres nos permite nombrar variables, funciones, estructuras, clases,
enumeraciones, etc. para evitar la colisión de nomenclaturas.
Un espacio de nombres debe de iniciar con la palabra reservada namespace seguido del
nombre del espacio de nombres.
En C++ se cuenta con el nombre de espacios estándar std en la biblioteca <iostream> que
maneja las entradas y las salidas.
El símbolo :: es el operador de resolución de ámbito o de alcance.
La directiva using llama al espacio de nombres y ya no es necesarios utilizar std::

1 //Espacios de [Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 cout<< "Escribe dos numeros" << endl;
6 int n1,n2;
7 cin >>n1 >> n2;
8 cout<< "la suma es " << n1 << "+" <<n2
9 << " es " << n1+n2 << endl;
10 return 0;
11 }
Listado 1.5.1. [Link]

Autor: Francisco J. Arce A. página 8/180 [Link]

 Introducción a C++

1.6. Los tipos de datos nativos en C++

Los tipos de datos nativos en C++ son:
● Enteros
● Coma flotante
● Lógicos
● Caracteres
● Referencia
● Enumeraciones
● Arreglos
● Nombres de tipos definidos por usuarios

Bool, booleanos, 1 bit

Char, caracter, 8 bits
Wchar_t, caracter ancho, 16 bits
Short, entero corto, 16 bits
Int, entero, 16 bits
Long, largo-entero, 32 bits
Float, precisión real simple, 6 dígitos significativos
Double, real doble precisión , 10 dígitos significativos
long double, real doble precisión extendido ,10 dígitos significativos
Los tipos de datos pueden cambiar dependiendo del compilador, de la computadora o del
sistema operativo
C++ es “ case sensitive ” es decir, distinguen entre mayúsculas y minúsculas, así que "int
numero;" es distinto de "int NUMERO;"
Las sentencias en C++ terminan en punto y coma “;” al igual que en C.

1 //tipos de [Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 int n1;
6 double area;
7 float superficie;
8 char letra;
9 //Enteros
10 cout<< "Los bytes de un numero entero son "
11 << sizeof(n1) << endl;
12 //Dobles
13 cout<< "Los bytes de un numero doble son "
14 << sizeof(area) << endl;
15 //Char
16 cout<< "Los bytes de tipo char son "
17 << sizeof(letra) << endl;
18 //Float

Autor: Francisco J. Arce A. página 9/180 [Link]

 Introducción a C++
19 cout<< "Los bytes de un numero float son "
20 << sizeof(superficie) << endl;
21 return 0;
22 }
Listado 1.6.1. [Link]

Autor: Francisco J. Arce A. página 10/180 [Link]

 Introducción a C++

1.7. Tipos reales o coma flotante

Los tipos de datos float, double y long double los valores reales o de “coma flotante”.
● float, 32 bits
● double, 64 bits
● long double, 96 o 128 bits

1 //tipos de [Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 int entero;
6 double doble;
7 float flotante;
8 long double longDouble;
9 //Enetero
10 cout<< "Los bytes de un numero entero son "
11 << sizeof(entero) << endl;
12 //Double
13 cout<< "Los bytes de un numero doble son "
14 << sizeof(doble) << endl;
15 //Float
16 cout<< "Los bytes de un numero float son "
17 << sizeof(flotante) << endl;
18 //Long
19 cout<< "Los bytes de un numero long double "
20 << sizeof(longDouble) << endl;
21 //
22 return 0;
23 }
Listado 1.7.1. [Link]

Autor: Francisco J. Arce A. página 11/180 [Link]

 Introducción a C++

1.8. Las Literales en el Lenguaje C++

Constantes literales
● 12 //decimal
● 012 //octal
● 0x12 //hexadecimal

Con signo, sin signo y largo

● 120u //Sin signo unsigned entero
● 1024L //Largo o long
● 5LU //Largo sin signo

Coma flotante
● 1.34e-3F //Notación científica
● 1.3456 //Simple precisión f o F
● 003f //Simple precisión
● 1E-3F //Simple precisión
● 1.2345E1L //Largo

Literales caracter
● ‘a’, ‘b’, ‘c’

Literales lógicas
● true, false

Literales de cadenas
● “Hola, cara de bola”
● “”
● ‘c’
● “c”

Cadenas concatenadas
Se utiliza un espacio, un tabulador o una salto de línea

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 cout << "Hola a todos"
6 " desde el maravilloso mundo"
7 " de C++"
8 << endl;
9 return 0;
10 }
Listado 1.8.1. [Link]

Autor: Francisco J. Arce A. página 12/180 [Link]

 Introducción a C++

1.9. Tipo apuntadores

● Los apuntadores (o punteros) hacen referencia a una dirección de memoria de otra variable, objeto o a una
función.
● El operador & produce la dirección de un valor.
● El operador * regresa el valor referenciado y nos sirve para declara un apuntador.
● Las variables tienen un nombre, un tipo y una dirección de memoria.

1 #include <iostream> //cin y cout

2 using namespace std;
3 /*
4 Apuntadores
5 */
6
7 int main(){
8 int num = 100;
9 //mostrar el valor de num
10 cout << num << endl;
11 //direccion de memoria
12 cout << &num << endl;
13 //tamaño de la variable
14 cout << sizeof(num) << endl;
15 return 0;
16 }
Listado 1.9.1. [Link]

Autor: Francisco J. Arce A. página 13/180 [Link]

 Introducción a C++

1.10. Constantes en el lenguaje C++

● Por medio del calificador const convertimos una variable en una constante simbólica.
● const int DIAS=7;
● También podemos crear una constante con la directiva #define.
● #define MESES 12

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 #define DIAS 7
5 int main(){
6 const int MESES=12;
7 cout << "Tenemos " << MESES
8 << " meses y cada semana tiene "
9 << DIAS << " dias" << endl;
10 //DIAS = 11; **error*
11 return 0;
12 }
Listado 1.10.1. [Link]

Autor: Francisco J. Arce A. página 14/180 [Link]

 Introducción a C++

1.11. Tipos de datos: referencias

● Una referencia es un nombre alternativo de un objeto o de una variable.
● En los programas, las referencias se utilizan principalmente como parámetros formales a funciones.
● Una referencia es un tipo compuesto que se define precediendo a un nombre de variable el símbolo & (operador
de dirección).
● Un tipo compuesto es un tipo que se define en términos de otro tipo.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a = 10;
7 int& ptr = a;
8
9 ptr = 100;
10
11 //ptr = &a; // no se utiliza en las referencias
12
13 //*ptr = 100;
14
15 cout << ptr << "," << a << endl;
16
17 return 0;
18 }
Listado 1.11.1. [Link]

Autor: Francisco J. Arce A. página 15/180 [Link]

 Introducción a C++

1.12. Tipos definidos: typedef

● Un typedef permite definir un sinónimo de un tipo de dato.
● La definición comienza con la palabra reservada typedef seguido por el tipo de dato y el identificador (nombre del
typedef).
● Un nombre de tipo puede ser utilizado como un especificador de tipos.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 typedef unsigned int entero;
7 typedef float decimal;
8 entero edad = 99;
9 decimal ingreso = 1000.50;
10 cout << "La edad maxima para entrar al sistema es de "
11 << edad << " anios" << endl;
12 return 0;
13 }
Listado 1.12.1. [Link]

Autor: Francisco J. Arce A. página 16/180 [Link]

 Introducción a C++

1.13. Tipo de datos: Enumeraciones

Declaramos una enumeración con la palabra reservada enum con una lista de enumeradores
separados por comas y encerrado en llaves {}
El primer elemento del enumerador tiene valor cero y así sucesivamente.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 enum DIAS {LUNES=10, MARTES=20,
7 MIERCOLES=30, JUEVES=40,
8 VIERNES=99};
9 //
10 cout << "El dia de hoy es " << VIERNES << endl;
11 //
12 return 0;
13 }
Listado 1.13.1. [Link]

Autor: Francisco J. Arce A. página 17/180 [Link]

 Introducción a C++

1.14. Tipo de datos: Arreglos

● Un arreglo (array, vector, matriz) es una colección de diferente elementos del mismo tipo.
● El número de elementos se debe de definir cuando se crea el arreglo.
● El acceso a los elementos se realiza con el nombre del arreglo, los corchetes y un número entero.
● El primer elemento siempre es cero.
● Se puede crear arreglos de diferentes dimensiones.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int edades[10];
7 int puntos[3][2] = {
8 {10,20},
9 {30,40},
10 {50,60}
11 };
12 edades[0] = 99;
13 edades[9] = edades[0]-9;
14 //
15 cout << "El primer elementos del arreglo es " << edades[0]
16 << " y el ultimo elemento es " << edades[9] << endl;
17 //
18 cout << "El primer punto cartesiano es "
19 << puntos[0][0] << ", "
20 << puntos[0][1] << endl;
21 //
22 return 0;
23 }
Listado 1.14.1. [Link]

Autor: Francisco J. Arce A. página 18/180 [Link]

 Introducción a C++

1.15. Tipo de dato: Caracteres

● El tipo char solo almacena un caracter.
● Un caracter es un número entero basado en el código ASCII

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 char a = 'a';
7 char b = 'B';
8 //
9 cout << "Si a la letra '" << a
10 << "' le restas 32 te dara la letra "
11 << (char) (a-32) << endl;
12 //
13 cout << "Si a la letra '" << b
14 << "' le sumas 32 te dara la letra "
15 << (char) (b+32) << endl;
16 //
17 return 0;
18 }
Listado 1.15.1. [Link]

Autor: Francisco J. Arce A. página 19/180 [Link]

 Introducción a C++

1.16. Tipo de dato: Cadenas o strings

● Una cadena es un valor entre dobles comillas que contiene cualquier combinación de caracteres (letras, números,
espacios, símbolos).
● Para utilizar cadenas debemos utilizar el archivo de cabecera <string>

1 //[Link]
2 #include <iostream>
3 #include <string>
4 using namespace std;
5
6 int main(){
7 string nombre = "Pedro";
8 string apellido = "Picapiedra";
9 string puesto = "Operador";
10 //
11 cout << "Tu nombre es " << apellido << ", " << nombre << endl
12 << "y tu puesto es de " << puesto << " de dinsuarios" << endl;
13 //
14 return 0;
15 }
Listado 1.16.1. [Link]

Autor: Francisco J. Arce A. página 20/180 [Link]

 Introducción a C++

1.17. Tipo de dato: Booleanos

● Un tipo de dato booleano tiene solo dos valores: verdadero (true), o diferente a cero, y falso (false), igual a cero.
● Se llama tipo booleano en honor al matemático británico George Boole.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 bool verdadero = 5555;
7 bool falso = false;
8 //
9 cout << "El valor verdadero es: " << verdadero
10 << " y el valor falso es " << falso << endl;
11 //
12 return 0;
13 }
Listado 1.17.1. [Link]

Autor: Francisco J. Arce A. página 21/180 [Link]

 Introducción a C++

1.18. Las variables en el Lenguaje C++

● Una variable se puede comparar con una caja donde guardamos y recuperamos un dato.
● Una variable debe de tener un tipo de dato y un nombre de variable.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int entero; //declaracion
7 entero = 10; //iniciacion
8 float distancia = 10.34; //declaracion e iniciacion
9 char a,b,c,d,e; //declarando varias variables
10 char f='f', g='g', h='h'; //declaramos e iniciamos variables
11 //
12 string apellidoPaterno = "picapiedra";
13 string apellido_materno = "de rocadura";
14 //
15 return 0;
16 }
Listado 1.18.1. [Link]

Autor: Francisco J. Arce A. página 22/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 2: Expresiones y operadores en el lenguaje C++
Objetivo: El alumno creará diferentes tipos de expresiones utilizando operadores, operandos y
literales.

Introducción:
Un punto fundamental en cualquier lenguaje de programación son las expresiones que nos
permitirán procesar la información de entrada, tanto del teclado como de los archivos de
datos. En este capítulo estudiaremos los siguientes operadores:
● Aritméticos
● Relacionales
● Lógicos
● Asignación
● Incremento y decremento
● Operador condicional
● Operador sizeof()
● Operador coma
 Introducción a C++

2.1. Operadores matemáticos o aritméticos

● Los operadores aritméticos siguen las reglas de la aritméticas tradicionales.
● Los operadores multiplicativos (multiplicación, división y residuo) tienen mayor precedencia que los operadores
aditivos (suma y resta).
● Por medio de los paréntesis podemos cambiar la precedencia.
● Los operadores + y - si se utilizan antes de un operando, tienen mayor precedencia y se consideran operadores
unarios.
● Las expresiones matemáticas entre paréntesis tienen prioridad sobre todos los operadores.
● Si los paréntesis están anidados se ejecutan de los más internos a los menos internos.
● Las subexpresiones entre paréntesis se evalúan en primer lugar según el modo estándar y los resultados se
combinan para evaluar la expresión completa.
● La asociatividad determina el origen en que se agrupan los operadores de igual prioridad, es decir, de izquierda a
derecha o de derecha a izquierda.

1 //operadores [Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a=10, b=20, c=5, r;
7
8 r = a + 10 * b - c;
9 cout << "El resultado es " << r << endl;
10 r = (a + 10) * b - c;
11 cout << "El resultado es " << r << endl;
12 r = (a + 10) * (b - c);
13 cout << "El resultado es " << r << endl;
14 return 0;
15 }
Listado 2.1.1. [Link]

Autor: Francisco J. Arce A. página 24/180 [Link]

 Introducción a C++

2.2. Operadores relacionales

● Cuando se utilizan los operadores en una expresión, el operador relacional produce un 0 (falso) o un 1 (verdadero).
● == igualdad
● != diferente
● > mayor que
● < menor que
● >= mayor igual
● <= menor que
● Los operadores relacionales tienen menor prioridad que los operadores aritméticos y tienen asociatividad de
izquierda a derecha.
● Los operadores relacionales permiten comprobar dos valores.

1 //operadores [Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a, b, c;
7 a = 10;
8 b = 20;
9 c = b;
10
11 cout << "A es mayor que B " << (a>b) << endl;
12 cout << "A es menor que B " << (a<b) << endl;
13 cout << "A es igual que B " << (a==b) << endl;
14 cout << "A es diferente que B " << (a!=b) << endl;
15
16 cout << "C es mayor que B " << (c>b) << endl;
17 cout << "C es menor que B " << (c<b) << endl;
18 cout << "C es igual que B " << (c==b) << endl;
19 cout << "C es diferente que B " << (c!=b) << endl;
20
21 return 0;
22 }
Listado 2.2.1. [Link]

Autor: Francisco J. Arce A. página 25/180 [Link]

 Introducción a C++

2.3. Operadores de asignación

● El símbolo de igualdad (=) será el operador de asignación.
● Asigna el valor de la derecha a una variable de la izquierda.
● Podemos hacer varias asignaciones evaluadas de derecha a izquierda:
● El lenguaje C++ tiene cinco símbolos de asignación o atajos:
● *= a*=b equivale a a = a * b;
● /= a/=b equivale a a = a / b;
● %= a%=b equivale a a = a % b;
● += a+=b equivale a a = a + b;
● -= a-=b equivale a a = a - b;

1 //operadores asignació[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a,b,c; //Declaracion
7 a = b = c = 20; //Asignacion
8 //
9 cout << "Las variables tienen en valor de "
10 << a << ", "
11 << b << ", "
12 << c << endl;
13 /* los atajos */
14 a*=10; // a = a * 10
15 b+=20; // b = b + 20
16 c-=10; // c = c - 10
17 cout << "Las variables tienen en valor de "
18 << a << ", "
19 << b << ", "
20 << c << endl;
21 a/=10; // a = a / 10
22 b%=3; // b = b % 3
23 cout << "Las variables tienen en valor de "
24 << a << ", "
25 << b << ", "
26 << c << endl;
27 return 0;
28 }
Listado 2.3.1. [Link]

Autor: Francisco J. Arce A. página 26/180 [Link]

 Introducción a C++

2.4. Operadores de incremento y decremento

● Los operadores de incremento (++) y de decremento (--) suman o restan, respectivamente, una unidad a la
variable.
● c++ equivale a c = c + 1;
● Estos operadores se pueden utilizar como prefijo o como sufijo.
● Si los operadores están de prefijos (++c), la operación de incremento o decremento se efectúa antes que la
operación de asignación.
● Si los operadores están de sufijos (c++), la asignación se efectúa primero y el incremento o decremento a
continuación.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a = 10, b = 20, c;
7 cout << "a=" << a <<" b=" << b << endl;
8 //prefijo
9 ++a;
10 --b;
11 cout << "a=" << a <<" b=" << b << endl;
12 //sufijo
13 a++;
14 b--;
15 cout << "a=" << a <<" b=" << b << endl << endl;
16 // con asignacion y prefijo
17 c = ++a;
18 cout << "a=" << a <<" c=" << c << endl;
19 // con asignacion y sufijo
20 c = a++;
21 cout << "a=" << a <<" c=" << c << endl;
22 //prefijo
23 cout << "a=" << ++a << endl;
24 //sufijo
25 cout << "a=" << a++ << endl;
26 cout << "a=" << a << endl;
27 return 0;
28 }
Listado 2.4.1. [Link]

Autor: Francisco J. Arce A. página 27/180 [Link]

 Introducción a C++

2.5. Operadores lógicos

● Los operadores lógicos en C++ son ! (not), && (and) y || (or)

● El operador ! tiene mayor prioridad que &&, y a su vez, && tiene mayor prioridad que ||.
● Los operadores matemáticos (+,-,/,*,%) tienen precedencia sobre los operadores relacionales (<,>,==,!=).
● Los operadores relacionales tienen prioridad sobre los operadores lógicos (&&,||,!).

Imagen 2.5.1. Los operadores logicos

Autor: Francisco J. Arce A. página 28/180 [Link]

 Introducción a C++

Imagen 2.5.2. Tabla de verdad del operador AND

Imagen 2.5.3. Tabla de verdad del operador OR

Autor: Francisco J. Arce A. página 29/180 [Link]

 Introducción a C++
1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a,b;
7 bool c;
8 a = 10;
9 b = 15;
10 c = a==b && a>5;
11 cout << "La expresion 'a==b && a>5' es " << c << endl;
12 c = a<b && a>5;
13 cout << "La expresion 'a<b && a>5' es " << c << endl;
14 c = a==b || a>5;
15 cout << "La expresion 'a<b || a>5' es " << c << endl;
16 c = (a==b) || (a>5) && !(b<10);
17 cout << "La expresion 'a<b || a>5' es " << c << endl;
18 c = ((a==b) || (a>5)) && !(b>10);
19 cout << "La expresion '((a==b) || (a>5)) && !(b>10)' es "
20 << c << endl;
21 return 0;
22 }
Listado 2.5.1. [Link]

Autor: Francisco J. Arce A. página 30/180 [Link]

 Introducción a C++

2.6. El operador condicional

● El operador condicional u operador ternario ? : regresa un valor dependiendo si la condición es verdadera o
falsa.
● Tiene asociatividad de derecha a izquierda.
● Si el resultado de la expresión condicional es verdadero (diferente a cero) regresa el primer valor, si es falso
(igual a cero) regresa el valor después de los dos puntos.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int ventas, comision, retardos;
7 ventas = 200;
8 retardos = 0;
9 comision = (ventas>100 && retardos <=1)? 80 : 0;
10 cout << "Tu comision por " << ventas
11 << " ventas y " << retardos
12 << " es de " << comision << endl;
13 return 0;
14 }
Listado 2.6.1. [Link]

Autor: Francisco J. Arce A. página 31/180 [Link]

 Introducción a C++

2.7. El operador coma

● El operador coma permite combinar dos o más expresiones separadas por comas en una sola línea. int a = 10, b
= 20;
● Se evalúa de izquierda a derecha.
● Tiene la más baja prioridad de los operadores.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a = 10, b = 20, c;
7 a++, b--;
8 cout << "Valores de a=" << a << " y de b="
9 << b << endl;
10 c = (a+=3, b-=4);
11 cout << "El valor de c es de " << c << endl;
12 c = (a+=3, a=b, a++);
13 cout << "El valor de c es de " << c
14 << " y el valor de a es " << a << endl;
15 return 0;
16 }
Listado 2.7.1. [Link]

Autor: Francisco J. Arce A. página 32/180 [Link]

 Introducción a C++

2.8. Operadores de bits

● Los operadores bits trabajan a nivel de bit y sólo aplican en las variables enteras int.
● Existen cinco operadores de bits binarias y una unaria. &, equivale a AND.
● Compara dos bits, si ambos son 1 el resultado es verdadero (1).

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a,b,c,d;
7 //
8 a = 0xd3; //211, 11010011
9 b = 0xf5; //245, 11110101
10 c = 0x1e; //30, 00011110
11 //
12 d = b & c; //11110101 & 00011110 => 00010100
13 cout << "El resultado de b&c es " << d << endl;
14 d = a | b; //11010011 & 11110101 => 11110111
15 cout << "El resultado de b&c es " << d << endl;
16 d = a ^ c; //11010011 ^ 00011110 => 11001101
17 cout << "El resultado de b&c es " << d << endl;
18 return 0;
19 }
Listado 2.8.1. [Link]

Autor: Francisco J. Arce A. página 33/180 [Link]

 Introducción a C++

2.9. Operador sizeof()

● Determina el tamaño de un tipo de dato o variable que ocupa en memoria en bytes.
● sizeof (variable)
● sizeof (tipoDato)
● sizeof (expresión)
● El operador sizeof() es unario.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int a;
7 char b;
8 long c;
9 float d;
10 bool e;
11 double f;
12 cout << "El tamanio de bytes del tipo 'int' es de: "
13 << sizeof(a) << endl;
14 cout << "El tamanio de bytes del tipo 'char' es de: "
15 << sizeof(b) << endl;
16 cout << "El tamanio de bytes del tipo 'long' es de: "
17 << sizeof(c) << endl;
18 cout << "El tamanio de bytes del tipo 'float' es de: "
19 <<sizeof(d) << endl;
20 cout << "El tamanio de bytes del tipo 'bool' es de: "
21 << sizeof(e) << endl;
22 cout << "El tamanio de bytes del tipo 'double' es de: "
23 << sizeof(f) << endl;
24 return 0;
25 }
Listado 2.9.1. [Link]

Autor: Francisco J. Arce A. página 34/180 [Link]

 Introducción a C++

2.10. Conversión de tipos

● Se le llama “conversión de tipos” cuando cambiamos el tipo de una variable sin cambiar su valor.
● Existe la conversión implícita (automática) y la conversión explícita (realizada por el programador).
● Dentro de la conversión implícita, el Lenguaje C++:
● Hace la conversión entre los tipos aritméticos (int, float, double).
● Convierte valores cuando se combinan tipos mixtos de expresiones.
● Convierte valores cuando se pasan parámetros a las funciones.
● Las conversiones más simples se les llaman promociones integrales (por int) convierte los tipos bool, char,
unsigned char, signed char y short a int.
● Las conversiones explícitas se realizan por la notación “modelo”:

(tipoDato) valor
tipoDato (valor)

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 //conversion explicita
7 int a = 10, b = 3;
8 float c;
9
10 c = (float) 10/3;
11 cout << "La division de " << a << " entre "
12 << b << " es de " << c << endl;
13 return 0;
14 }
Listado 2.10.1. [Link]

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 //conversion implicita
7 short corto;
8 int entero, resultado;
9 float flotante;
10 long largo;
11 double doble;
12
13 corto = 10;
14 entero = 20;
15 flotante = 30.33;
16 largo = 40.44;
17 doble = 50.55;
18 resultado = doble * largo;

Autor: Francisco J. Arce A. página 35/180 [Link]

 Introducción a C++
19 cout << "El resultado es " << resultado << endl;
20 return 0;
21 }
Listado 2.10.2. [Link]

Autor: Francisco J. Arce A. página 36/180 [Link]

 Introducción a C++

2.11. Operador new

● Por medio del operador new podemos obtener bloques de memoria.
● Podemos utilizar el operador new en cualquier tipo de dato.
● El operador new devuelve un puntero o apuntador, que es la dirección del bloque asignado de memoria.
● El tipo de dato del puntero debe coincidir con el tipo de dato solicitado.
● Si hay algún error se produce, el apuntador será NULL.
● Las sintaxis posibles son:

apuntador = new tipoDato

apuntador = new tipoDato (inicializador)
apuntador = new tipoDato [dimensión] ; // para arreglos
● El operador delete nos sirve para liberar la memoria creada con el operador new.
● El operador delete no borra el apuntador o puntero creado con new.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 //declarando y asignando
7 int* ptrEntero = new int(10);
8 char* ptrChar = new char[100];
9 //
10 int* ptrEntero2;
11 ptrEntero2 = new int[100];
12 //
13 delete ptrEntero2, ptrEntero, ptrChar;
14 return 0;
15 }
Listado 2.11.1. [Link]

Autor: Francisco J. Arce A. página 37/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 3: Estructuras condicionales lenguaje C++
Objetivo: El alumno aprenderá las diferentes estructuras condicionales dentro del lenguaje C++

Introducción:

● Las estructuras condicionales controlan el flujo de un programa.

● Las estructuras condicionales combinan instrucciones o sentencias individuales en una
simple unidad con una entrada y salida.
● Se utilizan las llaves {} para agrupar las sentencias.
 Introducción a C++

3.1. La sentencia if
● La sentencia if tiene la condición entre paréntesis y las sentencias entre llaves.
● Si sólo hay una sentencia, podemos omitir las llaves.
● Si la condicional se evalúa como verdadera (diferente a cero) se ejecuta el bloque de sentencias.
● Si la condición es falsa (igual a cero) no se ejecuta el bloque de sentencias y continúa el programa.

Imagen 3.1.1. Representacion de un condicional IF

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int n, num;
7 num = 5;
8 cout << "Adivina un numero entre 1 y 10" << endl;
9 cin >> n;
10 if (n==num) cout << "Muy bien, adivinaste el numero" << endl;
11 //
12 if (num>n) cout <<
13 "El numero magico es mayor al numero que escribiste"
14 << endl;
15 //
16 if (num<n) cout <<

Autor: Francisco J. Arce A. página 39/180 [Link]

 Introducción a C++
17 "El numero magico es menor al numero que escribiste"
18 << endl;
19 //
20 return 0;
21 }
Listado 3.1.1. [Link]

Autor: Francisco J. Arce A. página 40/180 [Link]

 Introducción a C++

3.2. La sentencia if-else

● Una variación de la sentencia if es la palabra reservada “else”, que ejecuta una sentencia o bloque de sentencias
si la condición es falsa (igual a cero).
● Puede existir una sentencia if sin else, pero no puede haber un else sin if.
● Si sólo hay una sentencia, tanto en if como en el else, se pueden omitir las llaves.

Imagen 3.2.1. Representacion de un condicional If-Else

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int num;
7 cout << "Escribe un numero entero" << endl;
8 cin >> num;
9 if(num%2){
10 cout << "El numero " << num << " es impar" << endl;
11 } else {
12 cout << "El numero " << num << " es par" << endl;
13 }
14 return 0;
15 }
Listado 3.2.1. [Link]

Autor: Francisco J. Arce A. página 41/180 [Link]

 Introducción a C++

3.3. Sentencias if anidadas

● Las sentencias condicionales if se pueden anidar una dentro de otra tanto en el bloque de if o en el bloque else.
● No hay límite en las sentencias anidadas.
● Se recomienda no anidar más de tres estructuras condicionales.
● También se siguen las reglas de las llaves cuando sólo hay una sentencia.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int n, num;
7 n = 5;
8 //
9 cout << "Adivina el numero entre 1 y 10" << endl;
10 cin >> num;
11 if (num==n){
12 cout << "Adivinaste el numero magico" << endl;
13 } else {
14 cout <<
15 "Segunda oportunidad: adivina el numero entre 1 y 10"
16 << endl;
17 cin >> num;
18 if (num==n){
19 cout << "Adivinaste el numero magico" << endl;
20 } else {
21 cout <<
22 "Tercera oportunidad: adivina el numero entre 1 y 10" << endl;
23 cin >> num;
24 if (num==n){
25 cout <<
26 "Adivinaste el numero magico en el tercer intento" << endl;
27 } else {
28 cout << "Eres muy mal adivinador el numero era " << n << endl;
29 }// tercera oportunidad
30 } // segunda oportunidad
31 } // primera oportunidad
32 return 0;
33 }
Listado 3.3.1. [Link]

Autor: Francisco J. Arce A. página 42/180 [Link]

 Introducción a C++

3.4. Sentencias else-if

● Cuando tenemos condiciones excluyentes podemos utilizar una estructura de tipo else-if.
● Si ninguna de las condiciones se cumplen, podemos agregar al final una sentencia else.
● Si cada una de las estructuras condicionales sólo tienen una sentencia, podemos omitir las llaves {}.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int edad;
7
8 cout << "Escribe tu edad" << endl;
9 cin >> edad;
10
11 if(edad<18)
12 cout << "Lo sentimos, no tienens edad para entrar a la pagina";
13 else if(edad<30)
14 cout << "Bienvenido a la pagina";
15 else if(edad<50)
16 cout << "Bienvenido, pero debeías pensarlo bien antes de entrar a la pagina";
17 else if(edad<60)
18 cout << "Puedes entrar a la pagina bajo tu responsabilidad";
19 else
20 cout << "Lo sentimos, sobrepasas la edad para entrar a la pagina";
21 cout << " tu edad es de " << edad << endl;
22 return 0;
23 }
Listado 3.4.1. [Link]

Autor: Francisco J. Arce A. página 43/180 [Link]

 Introducción a C++

3.5. La sentencia switch

● Por medio de la sentencia switch podremos seleccionar varias opciones de una variable o expresión simple.
● A esta variable o expresión se le conoce como expresión de control o selector.
● La sintaxis general de esta sentencia es:

switch (selector){
case valor: sentencias;
break;
case valor: sentencias;
break;
case valor: sentencias;
break;
…
default: sentencias;
}
● Cada valor debe de ser único.
● Si no se cumple ningún valor se ejecuta la sentencia default.
● Si se cumple un valor, se ejecutan las sentencias hasta encontrar una sentencia break.
● Los valores de la estructura case deben ser del mismo tipo que el selector.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int dia;
7
8 cout << "Dia de la semana (1=domingo... 7=sabado)" << endl;
9 cin >> dia;
10
11 switch(dia){
12 case 1: cout << "Hoy es domingo" << endl;
13 break;
14 case 2: cout << "Hoy es lunes" << endl;
15 break;
16 case 3: cout << "Hoy es martes" << endl;
17 break;
18 case 4: cout << "Hoy es miercoles" << endl;
19 break;
20 case 5: cout << "Hoy es jueves" << endl;
21 break;
22 case 6: cout << "Hoy es viernes" << endl;
23 break;
24 case 7: cout << "Hoy es sabado" << endl;

Autor: Francisco J. Arce A. página 44/180 [Link]

 Introducción a C++
25 break;
26 default: cout << "Ese dia no existe" << endl;
27 }
28 return 0;
29 }
Listado 3.5.1. [Link]

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int estado;
7
8 cout << "1. Soltero" << endl;
9 cout << "2. Casado" << endl;
10 cout << "3. Union libre" << endl;
11 cout << "4. Arrejuntado" << endl;
12 cout << "5. Es complicado" << endl;
13 cin >> estado;
14
15 switch(estado){
16 case 1:
17 case 5:
18 cout << "Felicidades, eres soltero" << endl;
19 break;
20 case 2:
21 case 3:
22 case 4:
23 cout << "Felicidades, eres casado" << endl;
24 break;
25 default: cout << "Ese estado no existe" << endl;
26 }
27 return 0;
28 }
Listado 3.5.2. [Link]

Autor: Francisco J. Arce A. página 45/180 [Link]

 Introducción a C++

3.6. Operador condicional

● El operador condicional u operador ternario ? : regresa un valor dependiendo si la condición es verdadera o falsa.
● Tiene asociatividad de derecha a izquierda.
● Si el resultado de la expresión condicional es verdadero (diferente a cero) regresa el primer valor, si es falso (igual
a cero) regresa el valor después de los dos puntos.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int precio, tipoCambio,total;
7 cout << "Teclee el valor del producto" << endl;
8 cin >> precio;
9
10 cout << "Teclee el tipo de cambio (0 si no hay tc)"
11 << endl;
12 cin >> tipoCambio;
13
14 total = (tipoCambio==0)? precio : precio * tipoCambio;
15 cout << "El precio total del producto es " << total;
16
17 (tipoCambio==0)? cout << " moneda nacional" :
18 cout << " al tipo de cambio de " << tipoCambio;
19
20 return 0;
21 }
Listado 3.6.1. [Link]

Autor: Francisco J. Arce A. página 46/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 4: Estructuras cíclicas en el lenguaje C++
Objetivo: El alumno aplicará las estructura cíclica como do..while, while y for, así como el
operador condicional.

Introducción:

● Las estructuras cíclicas o bucles nos darán “músculos” a nuestros programas.

● Son “parientes” de las estructuras de control, a diferencia que se repiten mientras la
sentencia de control sea verdadera.
● A cada repetición se le llama “bucle”, “ciclo” o “iteración”.
● Cuando la expresión condicional es falsa, se termina el bucle.
 Introducción a C++

4.1. La estructura while()

● La sentencia while() primero se hace la expresión condicional y luego el bloque de sentencias.
● También aplican las reglas de las llaves de las estructuras condicionales.
● Cada repetición del bucle se llama “iteración”.
● La representación del ciclo while es el siguiente:

Imagen 4.1.1. Representacion grafica de un ciclo while()

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 int main(){
5 int i=0; //variable de control
6 while(i<10){
7 cout << "El valor de i es " << i << endl;
8 i++; //incremento
9 }
10 cout << "El valor de i despues del ciclo es " << i << endl;
11 return 0;
12 }
Listado 4.1.1. [Link]

Autor: Francisco J. Arce A. página 48/180 [Link]

 Introducción a C++

4.2. La estructura do..while()

● La sentencia do..while() primero se hace el bloque de sentencias y luego la expresión condicional.
● También aplican las reglas de las llaves de las estructuras condicionales.
● Cada repetición del bucle se llama “iteración”.
● La representación del ciclo do..while es el siguiente:

Imagen 4.2.1. Representaion grafica de un ciclo do..while()

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int n, num, op, i;
7 n = 5;
8 op = 3;
9 i = 1;
10
11 do{
12 cout << "Adivina el numero magico entre 1 y 10, optunidad "
13 << i << " de " << op << endl;
14 cin >> num;
15 if(num==n){
16 cout << "Muy bien, adivinaste el numero magico" << endl;

Autor: Francisco J. Arce A. página 49/180 [Link]

 Introducción a C++
17 i = 99;
18 } else {
19 i++;
20 if(i>op){
21 cout << "Lo sentimos, eres muy malo para adivinar"
22 << endl;
23 }
24 }
25 }while(i<=op);
26 return 0;
27 }
Listado 4.2.1. [Link]

Autor: Francisco J. Arce A. página 50/180 [Link]

 Introducción a C++

4.3. El ciclo for()

● El ciclo for se utiliza, principalmente, cuando sabes el valor de inicio, el valor final y el incremento.
● Se puede contar con una o más variables de control del ciclo.
● El ciclo for se forma de tres partes o expresiones:
● Expresión de inicio: establece los valores iniciales de la variable de control.
● Expresión de control: el ciclo se repetirá mientras esta expresión sea verdadera o diferente de cero.
● Expresión de incremento o decremento: Modifica las variables de control del ciclo.

Imagen 4.3.1. Representacion grafica de un ciclo for()

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int i,j;
7
8 for(i=0; i<10; i++){
9 cout << "El valor de i es " << i << endl;
10 }
11 cout << "El valor de i saliendo del ciclo es "
12 << i << endl;
13 cout << "---------------------" << endl;
14 for(i=0, j=100; i<10; i++, j-=10){
15 cout << "El valor de i es " << i

Autor: Francisco J. Arce A. página 51/180 [Link]

 Introducción a C++
16 << " y el valor de j es " << j << endl;
17 }
18 cout << "El valor de i saliendo del ciclo es "
19 << i << endl;
20 cout << "---------------------" << endl;
21 for(i=10; i>0; i-=2){
22 cout << "El valor de i es " << i
23 << " y el valor de j es " << j << endl;
24 }
25 cout << "El valor de i saliendo del ciclo es "
26 << i << endl;
27 return 0;
28 }
Listado 4.3.1. [Link]

Autor: Francisco J. Arce A. página 52/180 [Link]

 Introducción a C++

4.4. Las sentencias break y continue

● Por medio de la sentencia break podemos salir del ciclo o bucle.
● Siempre se utiliza con una instrucción condicional.
● Por medio de la sentencia continue repetimos el ciclo sin ejecutar las instrucciones abajo de ella.
● También se utiliza con una instrucción condicional.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int n, num;
7 n=5;
8 cout <<
9 "Adivina el numero magico entre 1 y 10" << endl;
10
11 while(cin >> num){
12 if(num==n) break;
13 cout <<
14 "Ese no es el numero magico, intenta nuevamente"
15 << endl;
16 }
17 cout << "Muy bien, 5 es el numero magico" << endl;
18 return 0;
19 }
Listado 4.4.1. [Link]

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int i;
7 for(i=0; i<=100; i++){
8 if(i%5!=0) continue;
9 cout << "Multiplo de 5 es " << i << endl;
10 }
11 return 0;
12 }
Listado 4.4.2. [Link]

Autor: Francisco J. Arce A. página 53/180 [Link]

 Introducción a C++

4.5. Ciclos anidados

● Podemos anidar varios ciclos.
● Hay que tener cuidado en que no se confundan las variables de control.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int lineas, fila, blancos, cruces;
7 char blanco = ' ';
8 char cruz = '*';
9
10 lineas = 10;
11 for(fila=1; fila<lineas; fila++){
12 for(blancos = lineas-fila; blancos > 0; blancos--)
13 cout << blanco;
14 for(cruces=1; cruces < 2 * fila; cruces++)
15 cout << cruz;
16 cout << endl;
17 }
18
19 return 0;
20 }
Listado 4.5.1. [Link]

Autor: Francisco J. Arce A. página 54/180 [Link]

 Introducción a C++

4.6. Ciclos, enumeraciones y sentencias nulas

● Podemos utilizar las enumeraciones (enum) dentro de un ciclo for().
● También podemos crear sentencias nulas en los ciclos for().

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 enum dias{LUNES, MARTES, MIERCOLES,
7 JUEVES, VIERNES, SABADO, DOMINGO};
8 int dia;
9
10 for(dia=LUNES; dia<=DOMINGO; dia++)
11 cout << dia << endl;
12
13 return 0;
14 }
Listado 4.6.1. [Link]

1 //[Link]
2 #include <iostream>
3 using namespace std;
4
5 int main(){
6 int i;
7
8 //for(i=0; i<10; cout << i++ << endl);
9 i=0;
10 for(;;){
11 cout << i << endl;
12 if(i==10) break;
13 i++;
14 }
15 cout << "Valor de i despues del ciclo "
16 << i << endl;
17 return 0;
18 }
Listado 4.6.2. [Link]

Autor: Francisco J. Arce A. página 55/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 5: Funciones en el lenguaje C++
Objetivo: El alumno aprenderá a crear, llamar y pasar parámetros por valor o por referencia.

Introducción:
Las funciones creadas por el usuario nos servirán para no repetir código, pero también para
organizar nuestro código. Es como el dilema “¿Cómo te comerías un elefante?”. La respuesta
lógica es “pues poco a poco”. Así, grandes problemas los podemos resolver si lo podemos
resolver cualquier problema si lo dividimos en pequeños problemas y encontrarle solución.
Así que podemos dividir en pequeños problemas llamadas “funciones” y a cada función
encontrarle una solución.
 Introducción a C++

5.1. Fundamentos de las funciones creadas por el usuario

● Una función es un bloque de código de lenguaje C++ que no es ejecutado inmediatamente, sino que puede ser
"llamado" o ejecutado desde el código "principal".
● Una función es la definición de una "rutina" (o pequeño programa) que se puede ejecutar una o varias veces.
● Una analogía típica de una función es una receta de cocina:
● La sintaxis general para crear o definir una función es la siguiente:

tipo nombreFuncion( parámetros) {

sentencias;
return tipo;
}
● El nombre de las funciones sigue las reglas de los nombres en el lenguaje C++.
● Las funciones en el Lenguaje C++ se pueden llamar desde cualquier parte del programa.
● Necesitamos definir un “prototipo”.
● Un prototipo es el tipo de datos que regresará la función y los tipos de datos de sus parámetros.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 /** prototipos **/
5 int suma(int, int);
6 int main(){
7 int n1, n2, r;
8 n1 = 7; n2 = 8;
9 r = suma(n1,n2);
10 cout << "La suma de " << n1 << " mas "
11 << n2 << " es de " << r << endl;
12 //llamar a una función
13 cout << "La suma de 5 mas 3 es de " << suma(5,3) << endl;
14 return 0;
15 }
16 int suma(int num1, int num2){
17 return num1+num2;
18 }
Listado 5.1.1. [Link]

Autor: Francisco J. Arce A. página 57/180 [Link]

 Introducción a C++

5.2. Crear prototipos

● La declaración de una función se le conoce como “prototipo”.
● Un prototipo es la cabecera de la función, pero termina con punto y coma.
● Con los prototipos el compilador verifica las comprobaciones de las llamadas de las funciones.

1 //[Link]
2 #include <iostream>
3 using namespace std;
4 /** prototipos **/
5 float rectangulo(float, float);
6 float numero();
7 int main()
8 {
9 float base, altura;
10
11 cout << "Escribe la base del rectangulo" << endl;
12 base = numero();
13 cout << "Escribe la altura del rectangulo" << endl;
14 altura = numero();
15 cout << "El area de un rectangulo con base de "
16 << base << endl;
17 cout << "y una altura de " << altura << endl;
18 cout << "es de " << rectangulo(base,altura) << endl;
19
20 return 0;
21 }
22 float numero(){
23 float n;
24 do{
25 cin >> n;
26 }while(n<=0);
27 return n;
28 }
29 float rectangulo(float base, float altura){
30 return base * altura;
31 }
32
Listado 5.2.1. [Link]

Autor: Francisco J. Arce A. página 58/180 [Link]

 Introducción a C++

5.3. Parámetros múltiples en una función

● Por medio de las tres puntos (...) podemos indicarle a una función, y a su prototipo, que se van a recibir un
número indefinido de parámetros.
● Para ello, necesitamos el archivo de cabecera #include <cstdarg> con macros (funciones en línea).
● Dentro de este archivo está definido el tipo de datos va_list.
● La función va_start() inicializa el puntero para manejar la lista de datos pasada a la función.
● va_start(va_list puntero,ultimofijo);
● La función va_start() inicializa el apuntador de tal forma que referencia al primer parámetro de la lista.
● El segundo argumento es el último argumento fijo de la función que se está implementando.
● Con la función va_arg() se obtiene los argumentos sucesivos de la lista.

tipo va_arg(va_list puntero, tipo);

● Por último hay que llamar la función va_end(). De esta forma se queda el puntero interno preparado para las
siguientes llamadas.

1 #include <iostream>
2 #include <cstdarg>
3 using namespace std;
4 /*
5 Funciones - Parámetros no definidos
6 */
7 /*** prototipos ***/
8 void maximo(int n, ...);
9 int main()
10 {
11 cout << "Primera lista" << endl;
12 maximo(5, 9.4, 26.26, 17.17, 12.77, 25.90);
13 cout << "Segunda lista" << endl;
14 maximo(8, 9.4, 126.26, 7.17, 112.77, 225.90,
15 90.90, 123.45, 54.321);
16
17 return 0;
18 }
19 void maximo(int n, ...){
20 double max, act;
21 int i;
22
23 //definir el apuntador
24 va_list puntero;
25 //Iniciamos la lista
26 va_start(puntero,n);
27
28 //Iniciamos primer valor
29 max = act = va_arg(puntero, double);
30 cout << "Valor actual " << act << endl;
31
32 for(i=2; i <=n; i++){
33 //leemos el siguiente valor de la lista

Autor: Francisco J. Arce A. página 59/180 [Link]

 Introducción a C++
34 act = va_arg(puntero, double);
35 cout << "Valor actual " << act << endl;
36 if(act > max) max = act;
37 }
38 cout << "Valor maximo " << max << endl;
39 //limpiar el apuntador
40 va_end(puntero);
41 }
Listado 5.3.1. [Link]

Autor: Francisco J. Arce A. página 60/180 [Link]

 Introducción a C++

5.4. Pasar parámetros por valor o por referencia

● Por omisión los parámetros en las funciones del lenguaje C++ se pasan por valor.
● Si desea pasar un parámetro por referencia hay que utilizar una referencia.
● Para pasar una variable por referencia debemos utilizar & antes del nombre de la variable.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones - Parámetros por valor o por referencia
5 */
6 /*** Prototipos ***/
7 void funcion1(double x, double y);
8 void funcion2(double &x, double &y);
9 int main()
10 {
11 double x,y;
12
13 x= 5.6; y = 7.5;
14 cout << "x = " << x << ", y = " << y << endl;
15 funcion1(x,y);
16 cout << "x = " << x << ", y = " << y << endl;
17 funcion2(x,y);
18 cout << "x = " << x << ", y = " << y << endl;
19 return 0;
20 }
21 //Pasamos por valor
22 void funcion1(double x, double y){
23 x *= x;
24 y *= y;
25 }
26 //Pasamos por referencia
27 void funcion2(double &x, double &y){
28 x *= x;
29 y *= y;
30 }
31
32
Listado 5.4.1. [Link]

Autor: Francisco J. Arce A. página 61/180 [Link]

 Introducción a C++

5.5. Funciones en línea

● Las funciones en línea son segmentos de código que el preprocesador las sustituye antes de compilar.
● Son más rápidas que las funciones.
● Se utilizan cuando la función es una expresión, su código es pequeño y es muy utilizado en el programa.
● Con las funciones en línea aumenta el tamaño del código binario.
● Si el programa llama x veces a la función en línea, el preprocesador copiará x veces el código.

inline <tipo> <nombreFuncion>(<parámetros>);

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones - Funciones en linea
5 */
6 inline int mayor(int a, int b){
7 return (a>b)? a : b;
8 }
9 int main() {
10 cout << "El valor mayor entre 8 y 10 es "
11 << mayor(8,10) << endl;
12 cout << "El valor mayor entre 88 y 190 es "
13 << mayor(88,190) << endl;
14 cout << "El valor mayor entre 18 y 10 es "
15 << mayor(18,10) << endl;
16 return 0;
17 }
Listado 5.5.1. [Link]

Autor: Francisco J. Arce A. página 62/180 [Link]

 Introducción a C++

5.6. Valores por defecto

● Podemos definir valores por omisión en los parámetros de una función desde el prototipo.
● Sólo los últimos parámetros de las funciones pueden tener valores por omisión.
● Sólo los últimos parámetros pueden ser omitidos cuando se llama a una función.
● Cada uno de los valores por defecto debe especificarse bien en los prototipos, o bien en las declaraciones, pero
no en ambos.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones - Argumentos por omisión
5 */
6 int suma(int a=5, int b=10, int c=20);
7 int main() {
8 cout << "La suma de 5+10+20 es " << suma() << endl;
9 cout << "La suma de 7+10+20 es " << suma(7) << endl;
10 cout << "La suma de 7+8+20 es " << suma(7,8) << endl;
11 cout << "La suma de 7+8+9 es " << suma(7,8,9) << endl;
12 return 0;
13 }
14 int suma(int a, int b, int c){
15 return a + b + c;
16 }
Listado 5.6.1. [Link]

Autor: Francisco J. Arce A. página 63/180 [Link]

 Introducción a C++

5.7. Apuntadores como parámetros

● Podemos pasar un apuntador o puntero como parámetro de una función.
● Un apuntador es un objeto, por lo cual se pasará por referencia.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones - Argumentos apuntador
5 */
6 void funcion(int *ptr);
7 int main() {
8 int a;
9 int *ptr;
10
11 a = 100;
12 ptr = &a;
13 funcion(ptr);
14 cout << "a=" << a << endl;
15 cout << "ptr=" << *ptr << endl;
16 //Referencia
17 funcion(&a);
18 cout << "a=" << a << endl;
19 cout << "ptr=" << *ptr << endl;
20
21 return 0;
22 }
23 void funcion(int *ptr){
24 *ptr+=10;
25 }
26
Listado 5.7.1. [Link]

Autor: Francisco J. Arce A. página 64/180 [Link]

 Introducción a C++

5.8. Arreglos como parámetros

● El nombre de un arreglo en realidad es un apuntador al inicio del objeto.
● Si pasamos un arreglo como parámetro a una función, lo pasamos como referencia.
● Sin embargo, tenemos problemas para determinar el tamaño del arreglo, sobre todo cuando manejamos arreglos
de varias dimensiones dentro de una función.

1 #include <iostream>
2 using namespace std;
3 #define N 10
4 void funcion(int [], int);
5 int main() {
6 int arreglo[N] = {1,2,3,4,5,6,7,8,9,0};
7 funcion(arreglo,N);
8 return 0;
9 }
10 void funcion(int a[], int n){
11 for(int i=0; i<n; i++) cout << a[i] << " ";
12 cout << endl;
13 }
Listado 5.8.1. [Link]

Autor: Francisco J. Arce A. página 65/180 [Link]

 Introducción a C++

5.9. Arreglos de varias dimensiones como parámetros

Cuando pasamos un arreglo de más de una dimensión es obligatorio pasar el número de
elementos en las siguientes dimensiones dentro de los paréntesis.

1 #include <iostream>
2 using namespace std;
3 #define COL 3
4 #define REN 3
5 void mostrarTabla(int [][COL],int, int);
6 int main() {
7 int tabla[REN][COL] = {{1,2,3},{4,5,6},{7,8,9}};
8 mostrarTabla(tabla,REN,COL);
9 return 0;
10 }
11 void mostrarTabla(int a[][COL],int ren, int col){
12 for(int i=0; i<ren; i++){
13 for (int j = 0; j < col; j++){
14 cout << a[i][j] << " ";
15 }
16 cout << endl;
17 }
18 }
Listado 5.9.1. [Link]

Autor: Francisco J. Arce A. página 66/180 [Link]

 Introducción a C++

5.10. Regresar una referencia

● Una función puede regresar una referencia.
● La función prototipo es:

<tipoDato> &<nombreFuncion>(<parámetros>);

1 #include <iostream>
2 using namespace std;
3 /*** Prototipo referencia***/
4 int &funcion(int*,int);
5 int main() {
6 int arreglo[10] = {0,1,2,3,4,5,6,7,8,9};
7
8 funcion(arreglo,5)++;
9 cout << arreglo[5] << endl;
10
11 funcion(arreglo,8) = funcion(arreglo,2)+10;
12 cout << arreglo[8] << endl;
13 return 0;
14 }
15 int &funcion(int* a, int i){
16 return a[i];
17 }
Listado 5.10.1. [Link]

Autor: Francisco J. Arce A. página 67/180 [Link]

 Introducción a C++

5.11. Funciones recursivas

● Las funciones recursivas son aquellas que se llaman a sí mismas dentro de su bloque de sentencias.
● Debe existir alguna condición de terminación de las llamadas recursivas para evitar un bucle infinito de llamadas.

1 #include <iostream>
2 using namespace std;
3 /*** Prototipo referencia***/
4 long fibonacci(int);
5 int main () {
6 int n,k;
7
8 do{
9 cout << "Cuantos numeros de Fibonacci deseas:" << endl;
10 cin >> n;
11 }while(n<=1);
12
13 cout << "Numeros de Fibonacci:" << endl;
14 cout << "0 1 ";
15 for(k=2; k<=n; k++)
16 cout << fibonacci(k) << " ";
17
18 return(0);
19 }
20 long fibonacci(int n){
21 //0 1 1 2 3 5 8 13 ...
22 if(n==0 || n==1){
23 return n;
24 } else {
25 return fibonacci(n-2) + fibonacci(n-1);
26 }
27 }
Listado 5.11.1. [Link]

Autor: Francisco J. Arce A. página 68/180 [Link]

 Introducción a C++

5.12. Argumentos de la función main()

● Podemos “pasar” valores desde la llamada al programa del sistema operativo.
● Recibimos dos parámetros: el primero es argc (argument counter), que es el número de parámetros que
escribimos, y el segundo es un apuntador a un arreglo con los datos que escribimos (*argv[] argument values).
● El primer elemento (el cero) de este arreglo es el nombre del programa.

1 #include <iostream>
2 using namespace std;
3 /*** Prototipo referencia***/
4 long fibonacci(int);
5 int main (int argc, char *argv[]) {
6 int n,k;
7
8 if(argc==1){
9 n = 10;
10 } else {
11 n = atoi(argv[1]);
12 }
13
14 if(n<=2 || n>100){
15 cout << "Numero fuera de rango " << n << endl;
16 return 1;
17 }
18
19 cout << "Los primeros "<< n <<
20 " numeros de la serie de Fibonacci:" << endl;
21 cout << "0 1 ";
22 for(k=2; k<=n; k++)
23 cout << fibonacci(k) << " ";
24
25 return(0);
26 }
27 long fibonacci(int n){
28 //0 1 1 2 3 5 8 13 ...
29 if(n==0 || n==1){
30 return n;
31 } else {
32 return fibonacci(n-2) + fibonacci(n-1);
33 }
34 }
35
36
Listado 5.12.1. [Link]

Autor: Francisco J. Arce A. página 69/180 [Link]

 Introducción a C++

5.13. Las funciones sobrecargadas

En el lenguaje C++ podemos definir varias funciones con el mismo nombre pero con diferentes
número de parámetros o con el mismo número de parámetros pero con diferente tipo entre
ellos.

1 #include <iostream>
2 using namespace std;
3 /*** Prototipo referencia***/
4 int mayor(int a, int b);
5 char mayor(char a, char b);
6 double mayor(double a, double b);
7 int main (int argc, char *argv[]) {
8 cout << mayor('x','y') << endl;
9 cout << mayor(10.10,15.15) << endl;
10 cout << mayor(23,12) << endl;
11 return(0);
12 }
13 int mayor(int a, int b){
14 return (a>b)? a: b;
15 }
16 char mayor(char a, char b){
17 return (a>b)? a: b;
18 }
19 double mayor(double a, double b){
20 return (a>b)? a: b;
21 }
Listado 5.13.1. [Link]

1 #include <iostream>
2 using namespace std;
3 /*** Prototipo referencia***/
4 int mayor(int a, int b);
5 int mayor(int a, int b, int c);
6 int mayor(int a, int b, int c, int d);
7 int main (int argc, char *argv[]) {
8 cout << mayor(23,12) << endl;
9 cout << mayor(23,12,50) << endl;
10 cout << mayor(23,12,25,66) << endl;
11 return(0);
12 }
13 int mayor(int a, int b){
14 return (a>b)? a: b;
15 }
16 int mayor(int a, int b, int c){
17 return mayor(mayor(a,b),c);
18 }
19 int mayor(int a, int b, int c, int d){

Autor: Francisco J. Arce A. página 70/180 [Link]

 Introducción a C++
20 return mayor(mayor(a,b),mayor(c,d));
21 }
Listado 5.13.2. [Link]

Autor: Francisco J. Arce A. página 71/180 [Link]

 Introducción a C++

5.14. Funciones apuntadas

● Algunas funciones de librerías requieren que pasemos un apuntador de la función como parámetro.
● Por ejemplo, la función qsort() requiere en sus parámetros una función de comparación que debemos hacerla
nosotros.
● La función qsort() se encuentra en el archivo de cabecera <cstdlib>.

void qsort(
void *base,
size_t nmemb,
size_t tamanio,
int (*comparar)(const void *, const void *)
);
● Ordena un arreglo de nmemb objetos.
● El elemento inicial es apuntado por base.
● El tamaño de cada elemento del arreglo está especificado por tamanio.
● El contenido del arreglo es ordenado según una función de comparación apuntada por comparar, la cual es
llamada con dos argumentos que apuntan a los objetos a ser comparados.
● La función regresará un entero menor, igual, o mayor que cero si el primer objeto es considerado,
respectivamente a ser menor, igual, o mayor que el segundo.

1 #include <iostream>
2 #include <cstdlib>
3 using namespace std;
4 #define ELEMENTOS 20
5 /* Prototipo de la función */
6 int comparar(const void *arg1, const void *arg2);
7 int main()
8 {
9 int arreglo[ELEMENTOS], i;
10
11 /*Poblar el arreglo*/
12 for(i=0; i<ELEMENTOS; i++)
13 arreglo[i] = rand() % 100 + 1;
14
15 cout << "El arreglo antes de ser ordenado" << endl;
16 for(i=0; i<ELEMENTOS; i++)
17 cout << arreglo[i] << " ";
18
19 qsort(arreglo, ELEMENTOS, sizeof(arreglo[0]), &comparar);
20
21 cout << endl << "El arreglo despues de ser ordenado" << endl;
22 for(i=0; i<ELEMENTOS; i++)
23 cout << arreglo[i] << " ";
24
25 return 0;
26 }

Autor: Francisco J. Arce A. página 72/180 [Link]

 Introducción a C++
27 int comparar(const void *arg1, const void *arg2){
28 if(*(int *)arg1 < *(int *)arg2) return -1;
29 else if(*(int *)arg1 > *(int *)arg2) return 1;
30 return 0;
31 }
Listado 5.14.1. [Link]

Autor: Francisco J. Arce A. página 73/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 6: Funciones Librerias ANSI C
Objetivo: El alumno aprenderá las funciones estándar de las librerías ANSI C

Introducción:
En C++ podemos utilizar las librerías de ANSI C anteponiéndole al nombre de la librería la
letra “c” y eliminando la extensión .h, por ejemplo <ctime> en lugar de <time.h> o <cstdlib>
por <stdlib.h>.
 Introducción a C++

6.1. Funciones aleatorias

● rand(void): RAND_MAX en <cstdlib>
● srand(semilla): Inicializa el generador de número aleatorio. Se utiliza para el punto de inicio o semilla.

1 #include <iostream>
2 #include <cstdlib>
3 #include <ctime>
4 using namespace std;
5
6 #define MAX 100
7 #define randomize (srand(time(NULL)))
8 #define random(num) (rand()%num)
9 int main () {
10 int i;
11
12 //antes de la semilla
13 for(i=0; i<10; i++) cout << random(MAX) << " ";
14 cout << endl << endl;
15
16 //Usamos la semilla
17 randomize;
18 //despues de la semilla
19 for(i=0; i<10; i++) cout << random(MAX) << " ";
20 cout << endl << endl;
21
22 //Usamos la semilla
23 srand(1);
24 //despues de la semilla
25 for(i=0; i<10; i++) cout << random(MAX) << " ";
26
27 return(0);
28 }
Listado 6.1.1. [Link]

Autor: Francisco J. Arce A. página 75/180 [Link]

 Introducción a C++

6.2. Ejemplo funciones aleatorias

Aplicaremos las funciones aleatorias para crear un juego del número mágico.

1 #include <iostream>
2 #include <cstdlib>
3 #include <ctime>
4 using namespace std;
5
6 #define MAX 100
7 #define LIMITE 5
8 #define randomize (srand(time(NULL)))
9 #define random(num) (rand()%num+1)
10 int main () {
11 int i, n, num, op;
12
13 //Usamos la semilla
14 randomize;
15 //Iniciar variables
16 n = random(MAX);
17 op = 1;
18
19 //Ciclo
20 do{
21 cout << "Adivina el numero magico entre 1 y 100, oportunidad "
22 << op << " de " << LIMITE << endl;
23 cin >> num;
24 if(num>n) cout << "El numero " << num
25 << " es mayor al numero magico" << endl;
26 if(num<n) cout << "El numero " << num
27 << " es menor al numero magico" << endl;
28 if(num==n){
29 cout << "Adivinaste el numero magico" << endl;
30 break;
31 }
32 op++;
33 if(op>LIMITE){
34 cout << "Lo sentimos, no adivinaste el numero magico que era"
35 << n << endl;
36 break;
37 }
38 }while(n!=num);
39 return(0);
40 }
Listado 6.2.1. [Link]

Autor: Francisco J. Arce A. página 76/180 [Link]

 Introducción a C++

6.3. Desordenar un arreglo

Por medio de las funciones aleatorias podemos “barajar” o desordenar un arreglo.

1 #include <iostream>
2 #include <cstdlib>
3 #include <ctime>
4 using namespace std;
5
6 #define ELEMENTOS 7
7 #define randomize (srand(time(NULL)))
8 #define random(num) (rand()%num)
9 int main () {
10 string dias[ELEMENTOS] = {"Lunes","Martes","Miercoles",
11 "Jueves","viernes", "Sabado", "Domingo"};
12 int i, r;
13 string temp;
14
15 randomize;
16
17 for(i=0; i<ELEMENTOS; i++) cout << dias[i] << " ";
18 cout << endl << endl;
19
20 for(i=0; i<ELEMENTOS; i++){
21 r = random(ELEMENTOS);
22 temp = dias[i];
23 dias[i] = dias[r];
24 dias[r] = temp;
25 }
26
27 for(i=0; i<ELEMENTOS; i++) cout << dias[i] << " ";
28 return(0);
29 }
Listado 6.3.1. [Link]

Autor: Francisco J. Arce A. página 77/180 [Link]

 Introducción a C++

6.4. Funciones utilitarias

● int abs(int num); Calcula el valor absoluto de un entero num. Si el resultado no puede ser representado, el
comportamiento no está definido.
● int atoi(const char *numPtr); Convierte la porción inicial de la cadena apuntada por numPtr a una representación
de int.
● double atof(const char *numPtr); Convierte la porción inicial de la cadena apuntada por numPtr a una
representación de double.
● div_t div(int num, int denom); Calcula el cociente y resto de la división del numerador num entre el denominador
denom. Si la división es inexacta, el cociente resultante es el entero de menor magnitud que es el más próximo al
cociente algebraico. Si el resultado no puede ser representado, el comportamiento no está definido; de lo
contrario, quot * denom + rem igualará num.
● También se mantiene una versión para long, como labs(), ldiv

1 #include <iostream>
2 #include <cstdlib>
3 using namespace std;
4 /*
5 Funciones utilitarias
6 */
7
8 int main () {
9 div_t division;
10 char entero[5] = "1234";
11 char largo[11] = "123.456789";
12 division = div(83,3);
13 cout << "Cociente " << [Link] << endl;
14 cout << "Residuo " << [Link] << endl;
15 cout << "Convertir la cadena a entero " << atoi(entero) << endl;
16 cout << "Convertir la cadena a flotante " << atof(largo) << endl;
17 return(0);
18 }
19
Listado 6.4.1. [Link]

Autor: Francisco J. Arce A. página 78/180 [Link]

 Introducción a C++

6.5. Funciones matemáticas

● fabs (x), Valor absoluto de x
● ceil (x), Redondeo entero superior
● pow (x, y), Potencia de x elevado a y
● floor (x), Redondeo entero inferior
● sqrt (x), Raíz cuadrada de x
● exp (x), Exponenciación (número e elevado a x, siendo e = 2.71828)
● sin (x), Seno de x
● log (x), Logaritmo neperiano de x
● cos (x), Coseno de x
● log10 (x), Logaritmo decimal de x
● tan (x), Tangente de x
● atan (x), Arcotangente de x

1 #include <iostream>
2 #include <cmath>
3 using namespace std;
4 /*
5 Funciones Matemáticas
6 */
7 int main () {
8 float numero;
9 do{
10 cout <<
11 "Dame un numero y calculare su raiz cuadrada (0 para terminar)"
12 << endl;
13 cin >> numero;
14
15 if(numero==0.0){
16 cout << "Gracias, hasta la vista..." << endl;
17 } else {
18 cout << "La raiz cuadrada de " << numero
19 << " es " << sqrt(numero) << endl;
20 }
21 }while(numero!=0.0);
22 return(0);
23 }
Listado 6.5.1. [Link]

Autor: Francisco J. Arce A. página 79/180 [Link]

 Introducción a C++

6.6. Funciones trigonométricas

● sin (x), Seno de x
● cos (x), Coseno de x
● tan (x), Tangente de x
● sinh (x), Seno hiperbólico de x
● cosh (x), Coseno hiperbólico de x
● tanh (x), Tangente hiperbólico de x
● atan (x), Arcotangente de x
● atan2 (x,y), Arcotangente de x e y
● log (x), Logaritmo neperiano de x
● log10 (x), Logaritmo decimal de x

1 #include <iostream>
2 #include <cmath>
3 using namespace std;
4 /*
5 Funciones Trigonométricas
6 */
7 #define PI 3.14159265
8 int main () {
9 double x,y,r,g;
10 x = 7;
11 y = 17;
12 g = 180/PI;
13 r = atan2(y,x)*g;
14
15 cout << "Los grados del punto (" << x << " , " << y
16 << ") son de " << r << " grados." << endl;
17
18 return(0);
19 }
20
Listado 6.6.1. [Link]

Autor: Francisco J. Arce A. página 80/180 [Link]

 Introducción a C++

6.7. Funciones de tiempo

● time: toma el tiempo de la computadora.
● difftime: diferencia de valores de tiempo.
● gmtime: convierte time_t en formato UTF_time (apuntador)
● asctime: convierte time_t en cadena (apuntador)

Tipos
● time_t:

1 #include <iostream>
2 #include <ctime>
3 using namespace std;
4 /* Funciones Tiempo */
5 int main( )
6 {
7 long int i = 0;
8 time_t inicio, fin;
9 struct tm *ptrInicio, *ptrFin;
10
11 inicio = time(NULL);
12 for(i=0; i<10000; i++) cout << ".";
13 fin = time(NULL);
14 cout << endl;
15
16 cout << "Inicio: " << inicio << endl;
17 cout << "Final: " << fin << endl;
18 cout << "Tiempo transcurrido: " << difftime(fin,inicio)
19 << " segundos" << endl;
20
21 ptrInicio = gmtime(&inicio);
22 ptrFin = gmtime(&fin);
23 cout << "Inicio: " << asctime(ptrInicio);
24 cout << "Final: " << asctime(ptrFin);
25 return 0;
26 }
Listado 6.7.1. [Link]

Autor: Francisco J. Arce A. página 81/180 [Link]

 Introducción a C++

6.8. Funciones de tiempo: UTC

time_t:
struct tm {
int tm_sec; seconds after the minute (from 0)
int tm_min; minutes after the hour (from 0)
int tm_hour; hour of the day (from 0)
int tm_mday; day of the month (from 1)
int tm_mon; month of the year (from 0)
int tm_year; years since 1900 (from 0)
int tm_wday; days since Sunday (from 0)
int tm_yday; day of the year (from 0)
int tm_isdst; Daylight Saving Time flag
};

1 #include <iostream>
2 #include <ctime>
3 using namespace std;
4 /*
5 Funciones Tiempo
6 */
7 int main( )
8 {
9 int cdmx = -5;
10 int bs = -3;
11 int la = -7;
12 int paris = 2;
13 time_t utc;
14 struct tm *ptr;
15
16 time(&utc);
17
18 ptr = gmtime(&utc);
19
20 cout << "La hora en la Ciudad de Mexico: "
21 << ptr->tm_hour+cdmx << ":"
22 << ptr->tm_min << endl;
23
24 cout << "La hora en Buenos Aires: "
25 << ptr->tm_hour+bs << ":"
26 << ptr->tm_min << endl;
27
28 cout << "La hora en Los Angeles: "
29 << ptr->tm_hour+la << ":"
30 << ptr->tm_min << endl;

Autor: Francisco J. Arce A. página 82/180 [Link]

 Introducción a C++
31
32 cout << "La hora en Paris: "
33 << ptr->tm_hour+paris << ":"
34 << ptr->tm_min << endl;
35
36 ptr = localtime(&utc);
37
38 cout << "La hora local: " << asctime(ptr) << endl;
39
40 return 0;
41 }
42
Listado 6.8.1. [Link]

Autor: Francisco J. Arce A. página 83/180 [Link]

 Introducción a C++

6.9. Funciones para cadenas

● strcpy: copia la cadena 2 a la cadena 1.
● char *strcpy(char *s1, const char *s2);
● strcat: añade la cadena 2 a la cadena 1:
● char *strcat(char*s1, const char *s2);
● strcmp: regresa un valor mayor que 1 si la cadena s1 es mayor que s2, regresa un valor -1 si la cadena s1 es
menor a s2 y regresa 0 si son iguales.
● int strcmp(const char *s1, const char *s2);
● strlen: determina el número de caracteres de una cadena.
● size_t strlen(const char *s);
● strtok: divide una cadena en diferentes tokens o sub cadenas dependiendo de los delimitadores en s2.
● char *strtok(char *s1, const char *s2);

1 #include <iostream>
2 #include <cstring>
3 using namespace std;
4 /* Funciones Cadenas */
5 int main( )
6 {
7 char s1[100] = "Hola Mundo";
8 char s2[100];
9 int i;
10
11 strcpy(s2,s1);
12 strcpy(s2+4,", desde el maravilloso mundo de C++");
13 cout << s1 << endl << s2 << endl;
14
15 strcpy(s2,"Hola Mundo");
16 strcat(s2,", espero que aprendas mucho.");
17 cout << s2 << endl;
18
19 strcpy(s1,"Hola Mundo");
20 strcpy(s2,"Hola MUNDO");
21
22 i = strcmp(s1,s2);
23
24 if(i>0) cout << "La cadena '"<< s1
25 << "' es mayor a la cadena '" << s2 <<"'" << endl;
26 else if(i<0) cout << "La cadena '"<< s1
27 << "' es menor a la cadena '" << s2 <<"'" << endl;
28 else cout << "La cadena '"<< s1
29 << "' es igual a la cadena '" << s2 <<"'" << endl;
30
31 i = strncmp(s1,s2,8);
32
33 cout << "Comparar los primeros 5 caracteres:"<< endl;
34 if(i>0) cout << "La cadena '"<< s1
35 << "' es mayor a la cadena '" << s2 <<"'" << endl;
36 else if(i<0) cout << "La cadena '"<< s1

Autor: Francisco J. Arce A. página 84/180 [Link]

 Introducción a C++
37 << "' es menor a la cadena '" << s2 <<"'" << endl;
38 else cout << "La cadena '"<< s1
39 << "' es igual a la cadena '" << s2 <<"'" << endl;
40 return 0;
41 }
Listado 6.9.1. [Link]

Autor: Francisco J. Arce A. página 85/180 [Link]

 Introducción a C++

6.10. Funciones para cadenas: strtok

● strtok: divide una cadena en diferentes tokens o sub cadenas dependiendo de los delimitadores en s2.
● char *strtok(char *s1, const char *s2);

1 #include <iostream>
2 #include <cstring>
3 using namespace std;
4 /*
5 Funciones Cadenas
6 */
7 int main( )
8 {
9 char s1[81] = "En el agua clara que brota en la fuente un lindo pescado sale de repen
10 char s2[4] = " \n\t";
11 char *ptr;
12
13 cout << "La cadena original: " << s1 << endl;
14
15 /*Primera llamada*/
16 ptr = strtok(s1,s2);
17
18 cout << ptr << endl;
19
20 /* Las siguientes llamadas */
21 while((ptr = strtok(NULL,s2))!=NULL) cout << ptr << endl;
22
23 return 0;
24 }
25
Listado 6.10.1. [Link]

Autor: Francisco J. Arce A. página 86/180 [Link]

 Introducción a C++

6.11. Funciones de entrada

● [Link]: lee una cadena del teclado, incluyendo espacios.
● istream& getline(char* ptr, int len, char delim = '\n');
● [Link]: Ignora los caracteres que aún están pendientes de ser leídos:
● istream& ignore(int n=1, int delim = EOF);

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones Entrada
5 */
6 #define LON 100
7 int main( )
8 {
9 char titulo[LON], autor[LON];
10
11 cout << "Cual es tu libro preferido:" << endl;;
12 [Link](titulo,LON);
13
14 cout << "Autor:" << endl;
15 [Link](autor,LON);
16
17 cout << "Tu libro preferido es '" << titulo
18 << "' " << "y fue escrito por " << autor << endl;
19
20 return 0;
21 }
22
Listado 6.11.1. [Link]

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones Entrada
5 */
6 #define LON 100
7 int main( )
8 {
9 char nombre, apellido;
10
11 cout << "Escribe tu nombre y tu apellido" << endl;
12
13 nombre = [Link]();
14 [Link](100,' ');
15
16 apellido = [Link]();
17

Autor: Francisco J. Arce A. página 87/180 [Link]

 Introducción a C++
18 cout << "Tus iniciales son " << nombre << " "
19 << apellido << endl;
20
21 return 0;
22 }
23
Listado 6.11.2. [Link]

Autor: Francisco J. Arce A. página 88/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 7: Estructuras y apuntadores
Objetivo: El alumno aprenderá a crear y poblar estructuras y a utilizar los apuntadores en el
Lenguaje C++

Introducción:
En el lenguaje C++ no sólo podemos manejar gran variedad de tipos de datos básicos como
enteros, coma flotante o booleanos. También podemos crear estructuras o variables
agregadas como los arreglos o las estructuras. Muy parecido a los “objetos” de otros
lenguajes que provienen del Lenguaje C.
 Introducción a C++

7.1. Estructuras
● Una estructura es una colección de diferente tipos de datos.
● A cada elemento de una estructura se le llama miembro.
● Una definición de una estructura es:

struct <nombreEstructura>
{
<tipoDato> <nombreMiembro>;
<tipoDato> <nombreMiembro>;
<tipoDato> <nombreMiembro>;
...
};
● Podemos asignar valores por medio del operador = y las llaves con valores separados por comas.
● El operador sizeof() nos dará el espacio en bytes que ocupa la estructura en memoria.

1 #include <iostream>
2 using namespace std;
3 /*
4 Estructuras
5 */
6 struct libro{
7 char titulo[100];
8 char autor[100];
9 char editorial[100];
10 int anio;
11 int pag;
12 };
13 int main( )
14 {
15 struct libro libro1;
16 cout << "El numero de bytes en memoria de la estructura libro es de "
17 << sizeof(libro1) << endl;
18 return 0;
19 }
20
Listado 7.1.1. [Link]

Autor: Francisco J. Arce A. página 90/180 [Link]

 Introducción a C++

7.2. Poblar una estructura

● Para poblar o acceder a la información de un miembro de la estructura, podemos utilizar la notación punto o, por
medio de un puntero, utilizar la flecha:

<variable estructura>.<miembro>
O
<puntero estructura>-><miembro>

1 #include <iostream>
2 using namespace std;
3 /*Estructuras*/
4 struct libro{
5 char titulo[100];
6 char autor[100];
7 char editorial[100];
8 int anio;
9 int pag;
10 };
11 int main( )
12 {
13 struct libro *ptr;
14 struct libro libro1 = {"El llano en llamas",
15 "Juan Rulfo","Diana",1999,200};
16 ptr = &libro1;
17 //cambiamos un datos
18 [Link] = 2001;
19
20 //Notacion punto
21 cout << "Mi libro favorito es " << [Link]
22 << " y fue escrito por " << [Link] << endl;
23
24 //Apuntador y la flecha ->
25 cout << "Mi libro fue impreso en " << ptr->anio << " tiene "
26 << ptr->pag << " y es de la editorial " << ptr->editorial << endl;
27 return 0;
28 }
Listado 7.2.1. [Link]

Autor: Francisco J. Arce A. página 91/180 [Link]

 Introducción a C++

7.3. Estructuras anidadas

● Dentro de una estructura podemos utilizar otras estructuras.
● Se consideran estructuras anidadas.
● Accedemos a los datos por los puntos o por los apuntadores (punteros).

1 #include <iostream>
2 using namespace std;
3 /* Estructuras */
4 struct direccion{
5 char calle[40];
6 int numero;
7 char colonia[30];
8 };
9 struct usuario{
10 char nombre[40];
11 char apellidos[40];
12 struct direccion dir;
13 char telefono[15];
14 };
15 int main( )
16 {
17 struct usuario pepe = {
18 "Jose",
19 "Lopez",
20 {"Fuente del sol",12,"Fuentes de Satelite"},
21 "0445519719799"
22 };
23
24 cout << "Usuario: " << [Link] << ", "
25 << [Link] << endl;
26 cout << "Direccion: " << [Link] << " "
27 << [Link] << endl;
28 cout << "Colonia: " << [Link] << endl;
29 cout << "Telefono: " << [Link] << endl;
30 return 0;
31 }
Listado 7.3.1. [Link]

Autor: Francisco J. Arce A. página 92/180 [Link]

 Introducción a C++

7.4. Definir tipos con typedef

● Por medio de la palabra reservada typedef podemos definir nuestros propios tipos de datos a partir de los tipos
básicos del Lenguaje C++.
● Su sintaxis sería:

typedef <tipoDatoExistente> <nuevoNombre>

1 #include <iostream>
2 using namespace std;
3 /* Estructuras */
4 struct stDireccion{
5 char calle[40];
6 int numero;
7 char colonia[30];
8 };
9 typedef struct stDireccion direccion;
10 typedef struct stUsuario{
11 char nombre[40];
12 char apellidos[40];
13 direccion dir;
14 char telefono[15];
15 } usuario;
16 int main( )
17 {
18 usuario pepe = {
19 "Jose","Lopez",
20 {"Fuente del sol",12,"Fuentes de Satelite"},
21 "0445519719799"
22 };
23
24 cout << "Usuario: " << [Link] << ", "
25 << [Link] << endl;
26 cout << "Direccion: " << [Link] << " "
27 << [Link] << endl;
28 cout << "Colonia: " << [Link] << endl;
29 cout << "Telefono: " << [Link] << endl;
30 return 0;
31 }
Listado 7.4.1. [Link]

Autor: Francisco J. Arce A. página 93/180 [Link]

 Introducción a C++

7.5. Arreglos de estructuras

● Podemos definir un arreglo de estructuras.
● Accedemos a la información con el elemento del arreglo y la notación punto.

1 #include <iostream>
2 #include <cstring>
3 using namespace std;
4 /*
5 Estructuras
6 */
7 struct stLibro{
8 char titulo[100];
9 char autor[100];
10 int anio;
11 } libro[4] = {"El llano en llamas", "Juan Rulfo", 1999,
12 "Cien anios de soledad","Garcia Marquez", 2010,
13 "La guerra del fin del mundo","Mario Vargas Llosa", 2001};
14 int main( )
15 {
16 int i;
17
18 strcpy(libro[3].titulo,"El laberinto de la soledad");
19 strcpy(libro[3].autor,"Octavio Paz");
20 libro[3].anio = 2015;
21
22 cout <<"Mis libros favoritos" << endl;
23 for(i=0; i<4; i++){
24 cout << (i+1) << ") " << libro[i].titulo << ", " << libro[i].autor
25 << " impreso en " << libro[i].anio << endl;
26 }
27
28 return 0;
29 }
Listado 7.5.1. [Link]

Autor: Francisco J. Arce A. página 94/180 [Link]

 Introducción a C++

7.6. Estructuras anónimas

● Podemos crear estructuras anónimas, es decir, sin nombre, pero sólo dentro de otra estructura o unión.
● Se llaman con la notación punto como cualquier otro elemento de la estructura.

1 #include <iostream>
2 using namespace std;
3 /*
4 Estructuras
5 */
6 struct direccion{
7 char calle[40];
8 struct {
9 int numInterior;
10 int numExterior;
11 char referencia[40];
12 };
13 char colonia[40];
14 } dir1 = {"Calle de la soledad", 10, 2,
15 "Puerta negra",
16 "Jardines de Bellavista"};
17 int main( )
18 {
19 cout << [Link] << " int. " << [Link]
20 << " ext. " << [Link] << ", ref. "
21 << [Link] << ", col. " <<[Link];
22
23 return 0;
24 }
Listado 7.6.1. [Link]

Autor: Francisco J. Arce A. página 95/180 [Link]

 Introducción a C++

7.7. Utilizar estructuras como parámetros

Podemos pasar las estructuras completas como parámetros por valor o por referencia

1 #include <iostream> //[Link]

2 #include <cstring> //strcpy
3 #include <cstdlib> //atoi
4 using namespace std;
5 /* Estructuras como parámetros */
6 struct libros{
7 char titulo[100];
8 char autor[100];
9 int pag;
10 };
11 /* Prototipos */
12 void captura(struct libros* ptr);
13 void muestra(struct libros libro);
14 int main()
15 {
16 struct libros preferido;
17 //pasar por referencia
18 captura(&preferido);
19 //pasar por valor
20 muestra(preferido);
21 return 0;
22 }
23 void captura(struct libros *ptr){
24 char cadena[100];
25 cout << "Titulo de tu libro preferido:" << endl;
26 [Link](cadena,100);
27 strcpy(ptr->titulo,cadena);
28
29 cout << "Autor:" << endl;
30 [Link](cadena,100);
31 strcpy(ptr->autor,cadena);
32
33 cout << "Num. paginas:" << endl;
34 [Link](cadena,100);
35 ptr->pag = atoi(cadena);
36 }
37 //Pasamos por valor
38 void muestra(struct libros libro){
39 cout << "Tu libro preferido es " << [Link] << endl;
40 cout << "y fue escrito por " << [Link] << endl;
41 cout << "y tiene " << [Link] << " paginas." << endl;
42 }
Listado 7.7.1. [Link]

Autor: Francisco J. Arce A. página 96/180 [Link]

 Introducción a C++

7.8. Uniones
● Las uniones son estructuras que permiten almacenar diferentes elementos de diferente tipo en el mismo espacio,
pero no en forma

union [<identificador>] {
[<tipo> <nombre_variable>[,<nombre_variable>,...]];
} [<variable_union>[,<variable_union>,...];
● Todos los miembros de una unión ocupan el mismo espacio e inician en el mismo punto.
● La longitud de una unión es su miembro más largo.
● El operador sizeof() nos indicará la longitud de la unión en bytes.

1 #include <iostream> //cin y cout

2 using namespace std;
3 /* Estructuras y uniones */
4 struct libros{
5 char titulo[100];
6 char autor[100];
7 int pag;
8 };
9 union mensaje{
10 char error[100];
11 char alerta[80];
12 char ayuda[120];
13 };
14 enum dias{LUNES, MARTES, MIERCOLES, JUEVES, VIERNES};
15 int main()
16 {
17 cout << "La estructura se suman los miembros " <<
18 sizeof(struct libros) << endl;
19
20 cout << "En una union NO se suman los miembros " <<
21 sizeof(union mensaje) << endl;
22
23 cout << "En una enumeracion siempre regresa un entero "
24 << sizeof(enum dias) << endl;
25 return 0;
26 }
Listado 7.8.1. [Link]

Autor: Francisco J. Arce A. página 97/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 8: Apuntadores o punteros en lenguaje C++
Objetivo: El alumno creará y modificará los apuntadores o punteros en el lenguaje C++

Introducción:
Los apuntadores o punteros son una herramienta fundamental en los lenguajes como C y
C++, que nos permitirá tener completo control de tipos de datos, arreglos, estructuras y
funciones.
 Introducción a C++

8.1. Introducción a los apuntadores

● Un apuntador o puntero es una variable que contiene la dirección de memoria de otra variable.
● Cuando se declara una variable se asigna nombre, dirección y tipo.

1 #include <iostream> //cin y cout

2 using namespace std;
3 /*
4 Apuntadores
5 */
6
7 int main(){
8 int num = 100;
9 //mostrar el valor de num
10 cout << num << endl;
11 //direccion de memoria
12 cout << &num << endl;
13 //tamaño de la variable
14 cout << sizeof(num) << endl;
15 return 0;
16 }
Listado 8.1.1. [Link]

Autor: Francisco J. Arce A. página 99/180 [Link]

 Introducción a C++

8.2. Definición y asignación de un apuntador

● Los apuntadores deben ser declarados ANTES de ser utilizados.
● Para declarar un apuntador precedemos un asterisco (*) a su nombre.
● Hay que inicializar (o iniciar) el apuntador ANTES de utilizarlo.
● Para asignar una variable de memoria a un apuntador utilizamos el &.
● El operador asterisco (*) también sirve para obtener el contenido de una variable apuntador o para modificar el
contenido del objeto apuntado.

1 #include <iostream> //cin y cout

2 using namespace std;
3 /*
4 Apuntadores Asignacion
5 */
6
7 int main(){
8 int num = 10;
9 //Declaramos el apuntador
10 int* ptrNum;
11 //Asignamos el valor al apuntador
12 ptrNum = &num;
13 //Asignar un valor
14 *ptrNum = 50;
15 //Mostramos valor de la variable
16 cout << num << endl;
17 //Mostramos valor del apuntador
18 cout << *ptrNum << endl;
19 //Mostramos la direccion del apuntador
20 cout << ptrNum << endl;
21 return 0;
22 }
Listado 8.2.1. [Link]

Autor: Francisco J. Arce A. página 100/180 [Link]

 Introducción a C++

8.3. Apuntadores especiales: NULL y void

● Un apuntador nulo no apunta a ningún segmento de memoria.
● Para crear un apuntador nulo le asignamos la constante NULL (que tiene el valor de cero).
● También puedes declarar un apuntador nulo asignándole el número cero.
● Un apuntador genérico puede apuntar a cualquier tipo de dato pero para consultar los datos, debes de definirlo
*(tipo dato*)prt

1 #include <iostream> //cin y cout

2 using namespace std;
3 /*
4 Apuntadores Nulo y Generico
5 */
6
7 int main(){
8 //Apuntador nulo
9 //int* ptr = NULL;
10 int* ptr = 0;
11 //Apuntador generico
12 void* ptrGenerico;
13 float numero = 5.4567;
14
15 //Asignamos el objeto al apuntador
16 ptrGenerico = &numero;
17
18 if(ptr==NULL) cout << "El apuntador es nulo y ..." << endl;
19
20 cout << "El valor es " << *(float*)ptrGenerico << endl;
21 return 0;
22 }
Listado 8.3.1. [Link]

Autor: Francisco J. Arce A. página 101/180 [Link]

 Introducción a C++

8.4. Apuntadores de apuntadores

● Un apuntador puede apuntar a otro apuntador.
● Para declarar un apuntador a un apuntador usamos dos asterísticos (**) y así sucesivamente.

1 #include <iostream> //cin y cout

2 using namespace std;
3 /*
4 Apuntadores a apuntadores
5 */
6
7 int main(){
8 int numero = 100;
9 int* ptr1 = &numero;
10 int** ptr2 = &ptr1;
11 int*** ptr3 = &ptr2;
12
13 cout << "Lo que vale 'n': " << numero << endl;
14 **ptr2 = 200;
15 cout << "Lo que vale 'n': " << numero << endl;
16 *ptr1 = 300;
17 cout << "Lo que vale 'n': " << numero << endl;
18 ***ptr3 = 500;
19 cout << "Lo que vale 'n': " << numero << endl;
20 return 0;
21 }
Listado 8.4.1. [Link]

Autor: Francisco J. Arce A. página 102/180 [Link]

 Introducción a C++

8.5. Apuntadores y Arreglos

● En el Lenguaje C++ se pueden direccionar arreglos como apuntadores y apuntadores como arreglos.
● El nombre de un arreglo es en realidad un apuntador constante.
● Se puede utilizar la notación de apuntadores para visualizar un elemento en un arreglo.

1 #include <iostream> //cout

2 using namespace std;
3 /*
4 Apuntadores y arreglos
5 */
6
7 int main(){
8 float num[10];
9 float n = 1.2345;
10 int i;
11
12 //Poblar el arreglo
13 for(i=0; i<10; i++) *(num+i) = i * n;
14 //Desplegar el contenido del arreglo como apuntador
15 cout << "Desplegar el contenido del arreglo como apuntador"
16 << endl;
17 for(i=0; i<10; i++) cout << *(num+i) << " ";
18 cout << endl;
19
20 //Desplegar el contenido del arreglo como arreglo
21 cout << "Desplegar el contenido del arreglo como arreglo"
22 << endl;
23 for(i=0; i<10; i++) cout << num[i] << " ";
24 cout << endl;
25
26 return 0;
27 }
Listado 8.5.1. [Link]

Autor: Francisco J. Arce A. página 103/180 [Link]

 Introducción a C++

8.6. Arreglos de Apuntadores

● Podemos hacer un arreglo de apuntadores.
● Apuntan a un mismo tipo de dato.
● Un arreglo de arreglos (tabla o matriz) es un arreglo que apunta a otros arreglos (columnas).

1 #include <iostream> //cout

2 using namespace std;
3 /*
4 Apuntadores y arreglos
5 */
6
7 int main(){
8 float num[10];
9 float n = 1.2345;
10 int i;
11
12 //Poblar el arreglo
13 for(i=0; i<10; i++) *(num+i) = i * n;
14 //Desplegar el contenido del arreglo como apuntador
15 cout << "Desplegar el contenido del arreglo como apuntador"
16 << endl;
17 for(i=0; i<10; i++) cout << *(num+i) << " ";
18 cout << endl;
19
20 //Desplegar el contenido del arreglo como arreglo
21 cout << "Desplegar el contenido del arreglo como arreglo"
22 << endl;
23 for(i=0; i<10; i++) cout << num[i] << " ";
24 cout << endl;
25
26 return 0;
27 }
Listado 8.6.1. [Link]

Autor: Francisco J. Arce A. página 104/180 [Link]

 Introducción a C++

8.7. Apuntadores a cadenas

● Una cadena es un arreglo de caracteres en el Lenguaje C++.
● El nombre del arreglo (de cualquier tipo) es un apuntador.
● Por lo tanto, una cadena la podemos manejar con un apuntador o como un arreglo.

1 #include <iostream>
2 using namespace std;
3 /*
4 Manejar cadenas como apuntadores
5 */
6 int longitudArreglo(const char cadena[]);
7 int longitudApuntador(const char*);
8 int main(){
9 char cadena[] = "En el agua clara que borta en la fuente";
10 cout << "La longitud de la cadena '" << cadena <<
11 " es de " << longitudArreglo(cadena) << " caracteres."
12 << endl << endl;
13
14 cout << "La longitud de la cadena '" << cadena <<
15 "' es de " << longitudApuntador(cadena) << " caracteres."
16 << endl << endl;
17 }
18 int longitudArreglo(const char c[]){
19 int p = 0;
20 while(c[p] != '\0') p++;
21 return p;
22 }
23 int longitudApuntador(const char* c){
24 int p = 0;
25 while(*c++) p++;
26 return p;
27 }
Listado 8.7.1. [Link]

Autor: Francisco J. Arce A. página 105/180 [Link]

 Introducción a C++

8.8. Apuntadores constantes

● Un apuntador constante no puede cambiar el objeto al que apunta.
● El contenido del objeto apuntado si puede cambiar.
● Si el apuntador a una constante si puede cambiar, pero el contenido de la constante no puede cambiar.
● Para crear un apuntador constante se utiliza la siguiente sintaxis:
● <tipoDato> *const <puntero> = <dirección>
● También puede haber apuntadores constantes que apuntan a constantes.

1 #include <iostream>
2 using namespace std;
3 /*
4 Manejar apuntadores a constantes
5 SI podemos cambiar la dirección al que apuntamos
6 NO podemos cambiar el contenido
7 */
8 int main(){
9 //Constantes
10 const int x = 100;
11 const int y = 200;
12
13 //Creamos un apuntador
14 const int* ptr = &x;
15
16 //Cambiamos la dirección o referencia
17 //ptr = &y;
18
19 *ptr = 99;
20
21 return 0;
22 }
Listado 8.8.1. [Link]

1 #include <iostream>
2 using namespace std;
3 /*
4 Manejar apuntadores constantes
5 NO podemos cambiar la dirección al que apuntamos
6 SI podemos cambiar el contenido
7 */
8 int main(){
9 int x;
10 //Apuntador constante
11 int* const ptr = &x;
12 //Constante
13 int y = 10;
14
15 //Asignamos una nueva referencia

Autor: Francisco J. Arce A. página 106/180 [Link]

 Introducción a C++
16 //ptr = &y;
17
18 *ptr = 100;
19
20 return 0;
21 }
Listado 8.8.2. [Link]

1 #include <iostream>
2 using namespace std;
3 /*
4 Manejar apuntadores constantes a constantes
5 NO podemos cambiar la dirección al que apuntamos
6 NO podemos cambiar el contenido
7 */
8 int main(){
9 //Constantes
10 int z;
11 const int y = 10;
12 //Apuntador constante
13 const int* const ptr = &y;
14
15 //cambiamos la referencia (error)
16 //*ptr = &z;
17
18 //cambiar el valor de una constante (error)
19 *ptr = 100;
20
21 return 0;
22 }
Listado 8.8.3. [Link]

Autor: Francisco J. Arce A. página 107/180 [Link]

 Introducción a C++

8.9. Apuntadores a estructuras

● Los apuntadores o punteros también puede apuntar a una estructura.
● Apunta de la misma manera que a otras variables.

<struct> <identificador> *variable

● Para acceder a los datos utilizamos el apuntador y el operador ->.

1 #include <iostream>
2 using namespace std;
3 /* Libros */
4 struct libros{
5 char titulo[100]; char autor[100]; int pag;
6 };
7 typedef struct libros libro;
8 /* Prototipo */
9 void mostrarLibro(libro *ptr);
10 int main()
11 {
12 int i;
13 libro misLibros[] = {
14 {"El llano en llamas","Juan Rulfo",120},
15 {"El amor en tiempos del colera","Gabriel Garcia Marquez",800},
16 {"La guerra del fin del mundo","Mario Vargas Llosa", 800}
17 };
18 libro* ptr;
19 //Recibimos la referencia
20 ptr = misLibros;
21 for(i=0; i<3; i++, ptr++) mostrarLibro(ptr);
22 return 0;
23 }
24 void mostrarLibro(libro *ptr){
25 cout << "Titulo: " << ptr->titulo << endl;
26 cout << "Autor : " << ptr->autor << endl;
27 cout << "Paginas: " << ptr->pag << endl;
28 cout << "------------------" << endl;
29 }
Listado 8.9.1. [Link]

Autor: Francisco J. Arce A. página 108/180 [Link]

 Introducción a C++

8.10. Aritmética de apuntadores

● Los apuntadores o punteros (que no sean constantes) son variables que se pueden modificar.
● A los apuntadores podemos sumarles y restarles un número entero. Esto hace que apunte n posiciones adelante
o atrás.
● A una variable apuntador se le puede aplicar los operadores ++ y --.
● No se pueden sumar dos apuntadores entre ellos, ni multiplicar, ni dividir.

1 #include <iostream>
2 using namespace std;
3 /*Aritmetica de apuntadores*/
4 int main()
5 {
6 const int LON = 80;
7 char cadena[LON];
8 char* ptr;
9
10 cout << "Introduce una oracion:" << endl;
11 [Link](cadena,LON);
12
13 //Asignamos la referencia al apuntador
14 ptr = &cadena[0];
15
16 while(*ptr){
17 //Si a una minuscula restamos 32,
18 //la convertimos a mayuscula
19 if((*ptr>='a') && (*ptr<='z')) *ptr = *ptr - 32;
20 ptr++;
21 }
22
23 //Desplegamos la nueva cadena
24 cout << "La nueva cadena es: " << endl;
25 cout << cadena << endl;
26 return 0;
27 }
Listado 8.10.1. [Link]

Autor: Francisco J. Arce A. página 109/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 9: Espacios de nombres y clases: introducción a la
programación orientada a objetos
Objetivo: El alumno creará las clases y sus contructores en la programación orientada a
objetos en el lenguaje C++

Introducción:
La programación orientada a objetos convierte al lenguaje C++ es uno de los lenguajes más
poderosos para desarrollar. Los principios fundamentales serán; la abstracción, la herencia,
el polimorfismo y el encapsulamiento.
 Introducción a C++

9.1. Espacios de nombres

Un espacio de nombres o namespaces es un archivo separado donde podemos definir tipos
de datos, clases, estructuras, funciones, etc. al que se le asigna un identificador propio.
De momento hemos trabajado en lo que se denomina “espacio global”.
Los espacios de nombres nos permiten evitar los errores de “colisión de nomenclaturas” en
desarrollos grandes o con las bibliotecas externas.
Creamos un archivo de encabezado con la extensión “.h”.
Llamamos al archivo de encabezado con la directiva con “#include”.
Activamos el espacio de nombres con “using namespace”.
Podemos llamar a un espacio de nombres con el operador ::
Podemos crear un alias a un espacio de nombres.

1 #include <iostream>
2 #include "naves.h"
3 using namespace juego2D;
4 /*
5 Espacios de nombres
6 */
7 int main()
8 {
9 Nave nave1 = {10,20};
10 juego3D::Nave nave2 = {30,20,10};
11
12 std::cout << "Coordenadas de la nave 2D: "
13 << nave1.x << ", " << nave1.y << std::endl;
14
15 std::cout << "Coordenadas de la nave 3D: "
16 << nave2.x << ", " << nave2.y << ", "
17 << nave2.z << std::endl;
18
19 return 0;
20 }
Listado 9.1.1. [Link]

1 namespace juego2D{
2 struct Nave{
3 int x;
4 int y;
5 };
6 }
7 namespace juego3D{
8 struct Nave{
9 int x;
10 int y;

Autor: Francisco J. Arce A. página 111/180 [Link]

 Introducción a C++
11 int z;
12 };
13 }
Listado 9.1.1. naves.h

Autor: Francisco J. Arce A. página 112/180 [Link]

 Introducción a C++

9.2. Definición de clases en C++

Un objeto lo podemos definir como un conjunto de métodos y propiedades que responden a
ciertos eventos. Por ejemplo, un gato tiene características y tiene acciones que lo hacen único:
● Características o propiedades: Color de pelo, forma de las orejas, peso edad, raza, color de ojos, género, forma
de la cola, etcétera.
● Acciones que hacen los gatos: ronronear, maullar, comer, dormir, trepar, correr, saltar, cazar ratones, etcétera.
● Los gatos, a diferencia de otros animales, como los perros, responden a diferentes eventos.
● En programación orientada a objeto, un objeto es una colección de propiedades (datos) y métodos (códigos) que
pertenecen a una clase.

Lenguajes de Programación orientada a objetos

● Simula 67
● Smalltalk
● C++
● Java
● C#
● Objective-C

En la programación orientada a objetos, cada objeto es capaz de recibir mensajes, procesar

datos y enviar mensajes a otros objetos.
● Cada objeto puede verse como una pequeña “máquina independiente” con un papel o responsabilidad definida.
● Clase: Define las características del Objeto.
● Objeto: Una instancia de una Clase.

Elementos de un clase
● Propiedad: Una característica del Objeto, como el número de balas de un tanque.
● Método: Una capacidad del Objeto, como disparar().
● Constructor: Es un método llamado en el momento de la creación de instancias.
● Herencia: Una Clase puede heredar características de otra Clase.
● Encapsulamiento: Una Clase sólo define las características del Objeto, un Método sólo define cómo se ejecuta el
Método.
● Abstracción: La conjunción de herencia compleja, métodos, propiedades que un objeto debe ser capaz de simular
en un modelo de la realidad.
● Polimorfismo: Diferentes Clases podrían definir el mismo método o propiedad.

Modificadores de acceso
● Public: En todas partes
● Private: Sólo en la clase
● Protected: En la clase y en sus clases hijitas

Autor: Francisco J. Arce A. página 113/180 [Link]

 Introducción a C++

9.3. Definir una clase

● La definición básica de una clase es:

class <identificador>{
private:
<listado de propiedades y métodos>
public:
<listado de propiedades y métodos>
protected:
<listado de propiedades y métodos>
}

1 #include <iostream>
2 using namespace std;
3 /* Definición de clases */
4 class Nave{
5 private:
6 int x,y;
7 public:
8 void coordenadas(int x2, int y2){
9 x = x2;y = y2;
10 }
11 void leeCoordenadas(int &x2, int &y2){
12 x2 = x;y2 = y;
13 }
14 };
15 int main()
16 {
17 //Creamos la instancia
18 Nave nave1;
19 //Variables de trabajo
20 int x,y;
21 //Definimos las cordenadas de la nave
22 [Link](23,56);
23 //Recuperamos los valores de la nave
24 [Link](x,y);
25 //Desplegamos las coordenadas
26 cout << "La nave se encuentra en las coordenadas x="
27 << x << ", y=" << y << endl;
28 return 0;
29 }
Listado 9.3.1. [Link]

Autor: Francisco J. Arce A. página 114/180 [Link]

 Introducción a C++

9.4. Archivos de encabezados

● Por lo general, las clases se almacenan en archivos de cabecera con extensión “h”.
● La clase se llama con #include.
● Los métodos pueden ser definidos dentro de la clase (prototipos) e implementados fuera de la clase, pero dentro
del archivo de encabezado

1 #include <iostream>
2 #include "Nave.h"
3 using namespace std;
4 /* Definición de clases */
5 int main()
6 {
7 //Creamos la instancia
8 Nave nave1;
9 //Variables de trabajo
10 int x,y;
11
12 //Definimos las cordenadas de la nave
13 [Link](23,56);
14 //Recuperamos los valores de la nave
15 [Link](x,y);
16 //Desplegamos las coordenadas
17 cout << "La nave se encuentra en las coordenadas x="
18 << x << ", y=" << y << endl;
19 return 0;
20 }
Listado 9.4.1. [Link]

1 class Nave{
2 private:
3 int x,y;
4 public:
5 void coordenadas(int x2, int y2);
6 void leeCoordenadas(int &x2, int &y2);
7 };
8 void Nave::coordenadas(int x2, int y2){
9 x = x2;
10 y = y2;
11 }
12 void Nave::leeCoordenadas(int &x2, int &y2){
13 x2 = x;
14 y2 = y;
15 }
Listado 9.4.2. Nave.h

Autor: Francisco J. Arce A. página 115/180 [Link]

 Introducción a C++

9.5. Constructores
● Las funciones constructoras o constructores son funciones que nos permiten iniciar las instancias de las clases,
● El nombre de las funciones constructoras deben tener el mismo nombre de las clases.
● No regresan ningún valor, por lo que no tienen ningún tipo de dato, ni siquiera void.
● Tienen que ser públicas, nunca privadas o protegidas.
● Las funciones constructoras no se pueden heredar.

1 #include <iostream>
2 #include "Nave.h"
3 using namespace std;
4 /*
5 Definición de clases
6 */
7
8 int main()
9 {
10 //Creamos la instancia
11 Nave nave1(11,22);
12 //Variables de trabajo
13 int x,y;
14
15 //Recuperamos los valores de la nave
16 [Link](x,y);
17 //Desplegamos las coordenadas
18 cout << "La nave se encuentra en las coordenadas x="
19 << x << ", y=" << y << endl;
20 return 0;
21 }
Listado 9.5.1. [Link]

1 class Nave{
2 private:
3 int x,y;
4 public:
5 Nave(int x2, int y2);
6 void coordenadas(int x2, int y2);
7 void leeCoordenadas(int &x2, int &y2);
8 };
9 Nave::Nave(int x2, int y2){
10 x = x2;
11 y = y2;
12 }
13 void Nave::coordenadas(int x2, int y2){
14 x = x2;
15 y = y2;
16 }
17 void Nave::leeCoordenadas(int &x2, int &y2){

Autor: Francisco J. Arce A. página 116/180 [Link]

 Introducción a C++
18 x2 = x;
19 y2 = y;
20 }
Listado 9.5.2. Nave.h

Autor: Francisco J. Arce A. página 117/180 [Link]

 Introducción a C++

9.6. Iniciación en constructores

● Podemos iniciar los datos de la función constructora invocando los constructores implícitos antes de las llaves {}
de la función constructores.
● Sólo los constructores aceptan los inicializadores.
● Separamos los paréntesis de la función constructora de los inicializadores por medio de dos puntos (:).
● Se considera más óptimo usar inicializadores a la asignación tradicional.

1 #include <iostream>
2 #include "Nave.h"
3 using namespace std;
4 /*
5 Definición de clases
6 */
7
8 int main()
9 {
10 //Creamos la instancia
11 Nave nave1(33,44);
12 //Variables de trabajo
13 int x,y;
14
15 //Recuperamos los valores de la nave
16 [Link](x,y);
17 //Desplegamos las coordenadas
18 cout << "La nave se encuentra en las coordenadas x="
19 << x << ", y=" << y << endl;
20 return 0;
21 }
Listado 9.6.1. [Link]

1 class Nave{
2 private:
3 int x,y;
4 public:
5 Nave(int x2, int y2);
6 void coordenadas(int x2, int y2);
7 void leeCoordenadas(int &x2, int &y2);
8 };
9 Nave::Nave(int x2, int y2): x(x2), y(y2) {}
10 void Nave::coordenadas(int x2, int y2){
11 x = x2;
12 y = y2;
13 }
14 void Nave::leeCoordenadas(int &x2, int &y2){
15 x2 = x;
16 y2 = y;
17 }
Listado 9.6.2. Nave.h

Autor: Francisco J. Arce A. página 118/180 [Link]

 Introducción a C++

Autor: Francisco J. Arce A. página 119/180 [Link]

 Introducción a C++

9.7. Sobrecarga de constructores y otras características

● Podemos sobrecargar las funciones constructoras.
● Podemos crear parámetros por omisión en las funciones constructoras.
● La asignación entre objetos de la misma clase está permitida.
● Podemos crear funciones constructoras “de copia”.

1 #include <iostream>
2 #include "Nave.h"
3 using namespace std;
4 /* Definición de clases */
5 int main()
6 {
7 //Creamos la instancia
8 Nave nave1(333,444);
9 Nave nave2(nave1);
10 //Variables de trabajo
11 int x1,y1,x2,y2;
12
13 //nave2=nave1;
14
15 //Recuperamos los valores de la nave
16 [Link](x1,y1);
17 //Desplegamos las coordenadas
18 cout << "La nave 1 se encuentra en las coordenadas x="
19 << x1 << ", y=" << y1 << endl << endl;
20
21 //Recuperamos los valores de la nave
22 [Link](x2,y2);
23 //Desplegamos las coordenadas
24 cout << "La nave 2 se encuentra en las coordenadas x="
25 << x2 << ", y=" << y2 << endl;
26 return 0;
27 }
Listado 9.7.1. [Link]

1 class Nave{
2 private:
3 int x,y;
4 public:
5 Nave(int x2=0, int y2=0);
6 //constructor copia
7 Nave(const Nave &ptr);
8 void coordenadas(int x2, int y2);
9 void leeCoordenadas(int &x2, int &y2);
10 };
11 //Funciones constructoras
12 Nave::Nave(int x2, int y2): x(x2), y(y2) {}

Autor: Francisco J. Arce A. página 120/180 [Link]

 Introducción a C++
13 Nave::Nave(const Nave &ptr): x(ptr.x), y(ptr.y) {}
14 //Metodos
15 void Nave::coordenadas(int x2, int y2){
16 x = x2;
17 y = y2;
18 }
19 void Nave::leeCoordenadas(int &x2, int &y2){
20 x2 = x;
21 y2 = y;
22 }
Listado 9.7.2. Nave.h

Autor: Francisco J. Arce A. página 121/180 [Link]

 Introducción a C++

9.8. Destructores de instancias

● Tienen el mismo nombre de la clase, pero le anteponemos una tilde (~).
● No regresa ningún valor y no necesita tipo de dato.
● No puede ser heredado, debe ser público y no lleva parámetros.
● No puede ser sobrecargado.

1 #include <iostream>
2 #include "Nave.h"
3 using namespace std;
4 /* Definición de clases */
5
6 int main()
7 {
8 //Creamos la instancia
9 Nave nave1(333,444);
10 Nave nave2(nave1);
11 //Variables de trabajo
12 int x1,y1,x2,y2;
13
14 //nave2=nave1;
15
16 //Recuperamos los valores de la nave
17 [Link](x1,y1);
18 //Desplegamos las coordenadas
19 cout << "La nave 1 se encuentra en las coordenadas x="
20 << x1 << ", y=" << y1 << endl << endl;
21
22 //Recuperamos los valores de la nave
23 [Link](x2,y2);
24 //Desplegamos las coordenadas
25 cout << "La nave 2 se encuentra en las coordenadas x="
26 << x2 << ", y=" << y2 << endl;
27 return 0;
28 }
Listado 9.8.1. [Link]

Autor: Francisco J. Arce A. página 122/180 [Link]

 Introducción a C++

9.9. El apuntador this

● El apuntador this apunta a los elementos o miembros de su clase.
● Utilizamos el apuntador flecha.

1 #include <iostream>
2 using namespace std;
3 /*
4 El apuntador this
5 */
6 class Nave{
7 public:
8 Nave(){}
9 //Método
10 void identificate(Nave &c){
11 if(&c==this) cout << "No dispares" << endl;
12 else cout << "Dispara..." << endl;
13 }
14 };
15 int main()
16 {
17 Nave amiga, enemiga;
18
19 [Link](amiga);
20 [Link](enemiga);
21 return 0;
22 }
Listado 9.9.1. [Link]

Autor: Francisco J. Arce A. página 123/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 10: Funciones amigas y modificadores
Objetivo: El alumno podrá crear funciones amigas, funciones amigas en otras clases, crear
clases amigas, crear y usar getters y setters, crear funciones en línea, funciones constantes,
crear funciones con val

Introducción:
En C++ tenemos una amplia gama de herramientas en la programación orientada a objetos
que nos permitirá crear funciones amigas, funciones amigas en las clases o hacer clases
amigas, crear getters y setters. entre muchas más herramientas que harán muy potente
nuestra programación OOP.
 Introducción a C++

10.1. Funciones amigas

● Podemos declarar a una clase como amiga para que tenga acceso a toda la información de la clase (privados,
protegidos y públicos).
● La amistad también puede existir entre clases.
● Utilizamos la palabra reservada friend.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones amigas
5 */
6 class Nave{
7 public:
8 Nave(int n=0):balas(n){};
9 int numBalas(){
10 cout << "Balas desde la clase: " << balas << endl;
11 }
12 private:
13 int balas;
14 friend void numBalas(Nave n);
15 };
16 /* Prototipos */
17 void numBalas(Nave n);
18 int main()
19 {
20 Nave nave1(100);
21
22 [Link]();
23 numBalas(nave1);
24 return 0;
25 }
26 void numBalas(Nave n){
27 cout << "Balas desde la funcion amiga: " << [Link] << endl;
28 }
Listado 10.1.1. [Link]

Autor: Francisco J. Arce A. página 125/180 [Link]

 Introducción a C++

10.2. Funciones amigas en otras clases

● La función amiga puede encontrarse en otra clase.
● El procedimiento es el mismo para declarar funciones amigas externas, solo hay que utilizar el nombre de la clase
y el operador de resolución de alcance (::)

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones amigas en clases
5 */
6 class Nave;
7
8 class Asteroide{
9 public:
10 Asteroide(int v=0): velocidad(v) {}
11 void veloz(){
12 cout << "velocidad asteroide: " << velocidad << endl;
13 }
14 bool esVeloz(Nave n);
15 private:
16 int velocidad;
17 };
18
19 class Nave{
20 friend bool Asteroide::esVeloz(Nave n);
21 public:
22 Nave(int v=0): velocidad(v) {}
23 void veloz(){
24 cout << "velocidad nave: " << velocidad << endl;
25 }
26 private:
27 int velocidad;
28 };
29 /****************************/
30
31 /* Prototipos */
32 bool Asteroide::esVeloz(Nave n){
33 return velocidad > [Link];
34 }
35 int main()
36 {
37 Nave n(100);
38 Asteroide a(180);
39
40 [Link]();
41 [Link]();
42

Autor: Francisco J. Arce A. página 126/180 [Link]

 Introducción a C++
43 if([Link](n))
44 cout << "El asteroide es mas rapido que la nave" << endl;
45 else
46 cout << "La nave es mas rapida que el asteroide" << endl;
47 return 0;
48 }
Listado 10.2.1. [Link]

Autor: Francisco J. Arce A. página 127/180 [Link]

 Introducción a C++

10.3. Clases amigas

● Es más sencillo hacer dos clases amigas.
● La amistad no puede transferir.
● La amistad no se puede heredar.
● La amistad no es simétrica.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones amigas en clases
5 */
6 class Nave{
7 friend class Asteroide;
8 public:
9 Nave(int v=0): velocidad(v) {}
10 void veloz(){
11 cout << "velocidad nave: " << velocidad << endl;
12 }
13 private:
14 int velocidad;
15 };
16 /****************************/
17 class Asteroide{
18 public:
19 Asteroide(int v=0): velocidad(v) {}
20 void veloz(){
21 cout << "velocidad asteroide: " << velocidad << endl;
22 }
23 bool esVeloz(Nave n);
24 private:
25 int velocidad;
26 };
27
28
29 /* Prototipos */
30 bool Asteroide::esVeloz(Nave n){
31 return velocidad > [Link];
32 }
33 int main()
34 {
35 Nave n(100);
36 Asteroide a(180);
37
38 [Link]();
39 [Link]();
40
41 if([Link](n))

Autor: Francisco J. Arce A. página 128/180 [Link]

 Introducción a C++
42 cout << "El asteroide es mas rapido que la nave" << endl;
43 else
44 cout << "La nave es mas rapida que el asteroide" << endl;
45 return 0;
46 }
Listado 10.3.1. [Link]

Autor: Francisco J. Arce A. página 129/180 [Link]

 Introducción a C++

10.4. Getters y setters

● Una regla general de la programación orientada a objetos es que el usuario de la clase NUNCA debe tener
acceso directo a los datos de la clase.
● La única forma de acceder a los datos es por medio de funciones intermediarias, o setters (actualizan los datos) y
getters (recuperan los datos).

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones setters y getters
5 */
6 class Nave{
7 public:
8 Nave(int v=0, int vi=3, int b=100):
9 velocidad(v), vidas(vi), balas(b){};
10 //
11 void setBalas(int);
12 void setVidas(int);
13 void setVelocidad(int);
14 //
15 int getBalas();
16 int getVidas();
17 int getVelocidad();
18 private:
19 int velocidad, vidas, balas;
20 };
21 void Nave::setBalas(int b){
22 if(b<0) b = 0;
23 balas = b;
24 }
25 void Nave::setVidas(int v){
26 if(v<0) v = 0;
27 if(v>10) v = 10;
28 vidas = v;
29 }
30 void Nave::setVelocidad(int v){
31 if(v<0) v = 0;
32 if(v>100) v = 100;
33 velocidad = v;
34 }
35 //
36 int Nave::getBalas(){
37 return balas;
38 }
39 int Nave::getVidas(){
40 return vidas;
41 }

Autor: Francisco J. Arce A. página 130/180 [Link]

 Introducción a C++
42 int Nave::getVelocidad(){
43 return velocidad;
44 }
45
46 int main()
47 {
48 Nave nave1(100,5,50);
49
50 cout << "La nave tiene " << [Link]() << " vidas" << endl;
51 cout << "velocidad " << [Link]() << " geones luz" << endl;
52 cout << "y tiene " << [Link]() << " cartuchos" << endl;
53
54 [Link](70);
55 [Link](100);
56 [Link](2);
57
58 cout << endl << "diez minutos más tarde..." << endl;
59 cout << "La nave tiene " << [Link]() << " vidas" << endl;
60 cout << "velocidad " << [Link]() << " geones luz" << endl;
61 cout << "y tiene " << [Link]() << " cartuchos" << endl;
62
63
64 return 0;
65 }
Listado 10.4.1. [Link]

Autor: Francisco J. Arce A. página 131/180 [Link]

 Introducción a C++

10.5. Funciones en línea

● Podemos crear funciones en línea en una clase.
● Hay que definir el prototipo dentro de la clase y la implementación de la misma, afuera de la definición de la clase.
● La función debe ser pequeña.
● Las funciones implementadas en la definición de la clase, se consideran inline por omisión.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones inline
5 */
6 class Nave{
7 public:
8 Nave(int v);
9 void muestraVelocidad();
10 private:
11 int velocidad;
12 };
13 inline Nave::Nave(int v): velocidad(v){};
14 inline void Nave::muestraVelocidad(){
15 cout << "La velocidad es: " << velocidad << endl;
16 }
17
18 int main()
19 {
20 Nave nave1(100);
21
22 [Link]();
23
24 return 0;
25 }
Listado 10.5.1. [Link]

Autor: Francisco J. Arce A. página 132/180 [Link]

 Introducción a C++

10.6. Valores de retorno constantes

● Si reservamos una palabra reservada const entre los paréntesis y las llaves, el compilador impide que se
modifiquen los datos dentro de la función.
● Es muy útil para los getters.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones constantes
5 */
6 class Nave{
7 public:
8 Nave(int v=0);
9 void setVelocidad(int v);
10 int getVelocidad() const;
11 private:
12 int velocidad;
13 };
14 Nave::Nave(int v): velocidad(v){};
15 void Nave::setVelocidad(int v){
16 if(v<0) v = 0;
17 if(v>100) v = 100;
18 velocidad = v;
19 }
20 int Nave::getVelocidad() const {
21 return velocidad++;
22 }
23 int main()
24 {
25 Nave nave1(100);
26 [Link](80);
27 cout << "La velocidad de la nave es: " << [Link]()
28 << endl;
29
30 return 0;
31 }
Listado 10.6.1. [Link]

Autor: Francisco J. Arce A. página 133/180 [Link]

 Introducción a C++

10.7. Valores de retorno constantes

● Podemos marcar a una función para que regrese un valor constante con el modificador const.
● Es especialmente útil cuando regresamos apuntadores o punteros.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones constantes
5 */
6 class Nave{
7 public:
8 Nave(int v=0);
9 void setVelocidad(int v);
10 const int getVelocidad() const ;
11 private:
12 int velocidad;
13 };
14 Nave::Nave(int v): velocidad(v){};
15 void Nave::setVelocidad(int v){
16 if(v<0) v = 0;
17 if(v>100) v = 100;
18 velocidad = v;
19 }
20 const int Nave::getVelocidad() const {
21 return velocidad;
22 }
23 int main()
24 {
25 Nave nave1(100);
26 [Link](80);
27 cout << "La velocidad de la nave es: " << [Link]()
28 << endl;
29
30 return 0;
31 }
Listado 10.7.1. [Link]

Autor: Francisco J. Arce A. página 134/180 [Link]

 Introducción a C++

10.8. Sobrecarga de funciones miembro o métodos

Podemos sobrecargar funciones miembro o métodos en una clase con la misma restricción que
las funciones globales: no pueden tener el mismo número y tipo de datos de parámetros.

1 #include <iostream>
2 using namespace std;
3 /*
4 Funciones sobrecargadas
5 */
6 class Nave{
7 public:
8 Nave(int v=0, int vi=3, int b=10);
9 void modificaDatos(int v);
10 void modificaDatos(int v, int vi);
11 void modificaDatos(int v, int vi, int b);
12 const int getVelocidad() const ;
13 const int getVidas() const ;
14 const int getBalas() const ;
15 private:
16 int velocidad, vidas, balas;
17 };
18 Nave::Nave(int v, int vi, int b):
19 velocidad(v), vidas(vi), balas(b) {};
20
21 void Nave::modificaDatos(int v){
22 if(v<0) v = 0;
23 if(v>100) v = 100;
24 velocidad = v;
25 }
26 void Nave::modificaDatos(int v, int vi){
27 if(v<0) v = 0;
28 if(v>100) v = 100;
29 velocidad = v;
30
31 if(vi<0) vi = 0;
32 if(vi>5) vi = 5;
33 vidas = vi;
34 }
35 void Nave::modificaDatos(int v, int vi, int b){
36 if(v<0) v = 0;
37 if(v>100) v = 100;
38 velocidad = v;
39
40 if(vi<0) vi = 0;
41 if(vi>5) vi = 5;
42 vidas = vi;
43
44 if(b<0) b = 0;

Autor: Francisco J. Arce A. página 135/180 [Link]

 Introducción a C++
45 if(b>100) b = 100;
46 balas = b;
47 }
48 const int Nave::getVelocidad() const {
49 return velocidad;
50 }
51 const int Nave::getVidas() const {
52 return vidas;
53 }
54 const int Nave::getBalas() const {
55 return balas;
56 }
57 int main()
58 {
59 Nave nave1(100);
60 [Link](80,4,98);
61 cout << "La velocidad de la nave es: "
62 << [Link]() << endl;
63 cout << "Las vidas de la nave son: "
64 << [Link]() << endl;
65 cout << "Las balas de la nave son: "
66 << [Link]() << endl;
67
68 return 0;
69 }
Listado 10.8.1. [Link]

Autor: Francisco J. Arce A. página 136/180 [Link]

 Introducción a C++

10.9. Sobrecarga de operadores

● En estructuras y en clases no podemos utilizar directamente muchos operadores como los aritméticos, como la
suma, la resta, etc.
● Podemos crear funciones para ello.
● También podemos crear operadores “sobrecargados” que regresen un valor equivalente a los operadores
aritméticos.
● Los operadores que no se pueden sobrecargar son:
● Acceso a miembros de la clase (.)
● Indirección a miembros de la clase (.*)
● Resolución de ámbito (::)
● Operador condicional (? : )

1 #include <iostream>
2 using namespace std;
3 /*
4 Operadores sobrecargadas
5 */
6 class Tiempo{
7 public:
8 Tiempo(int h=0, int m=0): hora(h), min(m){};
9 void mostrar();
10 //Sobrecargamos el operador suma
11 Tiempo operator+(Tiempo h);
12 private:
13 int hora,min;
14 };
15 //
16 void Tiempo::mostrar(){
17 cout << hora << ":" << min << endl;
18 }
19 Tiempo Tiempo::operator+(Tiempo h){
20 Tiempo res;
21
22 [Link] = min + [Link];
23 [Link] = hora + [Link];
24
25 if([Link]>=60){
26 [Link] -= 60;
27 [Link]++;
28 }
29
30 return res;
31 }
32 int main()
33 {
34 Tiempo video1(1,10), video2(2,55), video3(0,40), total;
35
36 total = video1 + video2 + video3;

Autor: Francisco J. Arce A. página 137/180 [Link]

 Introducción a C++
37 [Link]();
38
39 return 0;
40 }
Listado 10.9.1. [Link]

Autor: Francisco J. Arce A. página 138/180 [Link]

 Introducción a C++

10.10. Sobrecarga de operadores unarios

Podemos sobrecargar operadores unarios, como ++ o == para la operación entre clases.

1 #include <iostream>
2 #include "Tiempo.h"
3 using namespace std;
4 /*
5 Operadores sobrecargadas
6 */
7
8 int main()
9 {
10 Tiempo video1(1,10), video2(2,55), video3(0,54), total;
11
12 total = video1 + video2 + video3;
13 [Link]();
14
15 cout << "Incrementamos el tiempo en un minuto" << endl;
16 ++total;
17 [Link]();
18
19 return 0;
20 }
Listado 10.10.1. [Link]

1 class Tiempo{
2 public:
3 Tiempo(int h=0, int m=0): hora(h), min(m){};
4 void mostrar();
5 //Sobrecargamos el operador suma
6 Tiempo operator+(Tiempo h);
7 //Sobrecargamos el operador ++
8 Tiempo & operator++();
9 private:
10 int hora,min;
11 };
12 //
13 void Tiempo::mostrar(){
14 std::cout << hora << ":" << min << std::endl;
15 }
16 Tiempo Tiempo::operator+(Tiempo h){
17 Tiempo res;
18
19 [Link] = min + [Link];
20 [Link] = hora + [Link];
21
22 if([Link]>=60){
23 [Link] -= 60;

Autor: Francisco J. Arce A. página 139/180 [Link]

 Introducción a C++
24 [Link]++;
25 }
26
27 return res;
28 }
29 Tiempo & Tiempo::operator++(){
30 min++;
31 if(min>=60){
32 min -= 60;
33 hora++;
34 }
35 return *this;
36 }
Listado 10.10.2. Tiempo.h

Autor: Francisco J. Arce A. página 140/180 [Link]

 Introducción a C++

10.11. Operadores de conversión de tipos

● Las clases no tienen conversión implícita entre ellas.
● Necesitamos escribir nuestras funciones de conversión con las siguientes característica:
● La función de conversión debe ser un método de la clase a convertir.
● La función de conversión No debe especificar un tipo de retorno.
● La función de conversión No debe tener argumentos.
● El nombre de la función debe ser el del tipo al que se quiere convertir el objeto.

1 #include <iostream>
2 #include <cmath>
3 #include "Punto.h"
4 #include "Polar.h"
5 using namespace std;
6 /*
7 Operadores sobrecargadas
8 */
9
10 int main()
11 {
12 Punto punto1;
13 Polar polar1(100.0, 0.785398);
14 //Conversion
15 punto1 = polar1;
16
17 cout << "El punto polar es: " << endl;
18 [Link]();
19
20 cout << "El punto cartesiano es: " << endl;
21 [Link]();
22
23 return 0;
24 }
Listado 10.11.1. [Link]

1 class Polar{
2 public:
3 Polar(){
4 radio = 0.0;
5 angulo = 0.0;
6 }
7 Polar(double r, double a){
8 radio = r; angulo = a;
9 }
10 void mostrar(){
11 std::cout << radio << ", " << angulo << std::endl;
12 }
13 //funcion de conversion

Autor: Francisco J. Arce A. página 141/180 [Link]

 Introducción a C++
14 operator Punto(){
15 double x = radio * cos(angulo);
16 double y = radio * sin(angulo);
17 return Punto(x,y);
18 }
19 private:
20 double angulo,radio;
21 };
Listado 10.11.2. Polar.h

1 class Punto{
2 public:
3 Punto(){
4 x = 0.0;
5 y = 0.0;
6 }
7 Punto(double xx, double yy){
8 x = xx; y = yy;
9 }
10 void mostrar(){
11 std::cout << x << ", " << y << std::endl;
12 }
13 private:
14 double x,y;
15 };
Listado 10.11.3. Punto.h

Autor: Francisco J. Arce A. página 142/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 11: Herencia y polimorfismo
Objetivo: El alumno creará clases derivadas con constructores, crear destructores de la
jerarquía de clases, funciones que se relacionen entre clases heredadas, sobreescribir
funciones en las clases heredadas

Introducción:
En esta sección revisaremos los principios de herencia y polimorfismo:
● Herencia: clases derivadas
● Constructores de una clase derivada
● Funciones que se relacionen entre clases heredadas,
● Sobreescribir funciones en las clases heredadas,
● Sobreescribir y sobrecargar funciones miembro,
● Herencia múltiples,
● Herencias virtuales, enlaces dinámicos,
● Funciones virtuales
● Polimorfismo.
 Introducción a C++

11.1. La herencia en el lenguaje C++

● La herencia nos permite crear clases nuevas (llamadas clases derivadas, clases hijas, clases heredadas) de
clases que ya existen previamente (llamadas clases madre, clases padre, clases base).
● Las clases derivadas conservan (heredan) las propiedades y métodos de la clase base.
● A la estructura de clases heredadas se le conoce como jerarquía de clases.
● En C++ una clase puede heredar de varias clases o herencia múltiple.
● La sintaxis general de una clase derivada es:

class <claseDerivada> : [public|private] <claseBase> {} ;]

1 #include <iostream>
2 #include "Armamento.h"
3 #include "Nave.h"
4 using namespace std;
5 /*
6 Herencia
7 */
8 int main()
9 {
10
11 return 0;
12 }
Listado 11.1.1. [Link]

1 class Armamento{
2 private:
3 int balas;
4 int vidas;
5 int velocidad;
6 public:
7 Armamento(int b, int vi, int v);
8 int getBalas() const;
9 int getVidas() const;
10 int getVelocidad() const;
11 };
Listado 11.1.2. Armamento.h

1 class Nave : public Armamento{

2 private:
3 int cohetes;
4 public:
5 Nave(int b, int vi, int v, int c);
6 int getCohetes() const;
7 };
Listado 11.1.3. Nave.h

1 class Tanque : public Armamento{

Autor: Francisco J. Arce A. página 144/180 [Link]

 Introducción a C++
2 private:
3 int lanzaLlamas;
4 public:
5 Nave(int b, int vi, int v, int l);
6 int getLanzaLlamas() const;
7 };
Listado 11.1.4. Tanque.h

Autor: Francisco J. Arce A. página 145/180 [Link]

 Introducción a C++

11.2. Constructores de las clases derivadas

Para iniciar un constructor de una clase base a partir de una clase derivada, debemos utilizar la
función constructora de la clase base con los parámetros requeridos.

1 #include <iostream>
2 #include "Armamento.h"
3 #include "Nave.h"
4 #include "Tanque.h"
5 using namespace std;
6 /*
7 Herencia
8 */
9 int main()
10 {
11 Tanque tanque1(100,3,20,50);
12 Nave nave1(100,5,100,3);
13
14 cout << "Las vidas del tanque son: "
15 << [Link]() << endl;
16 cout << "Las vidas de la nave son: "
17 << [Link]() << endl;
18 return 0;
19 }
Listado 11.2.1. [Link]

1 class Armamento{
2 private:
3 int balas;
4 int vidas;
5 int velocidad;
6 public:
7 Armamento(int b, int vi, int v):
8 balas(b), vidas(vi), velocidad(v){}
9 int getBalas() const { return balas; };
10 int getVidas() const { return vidas; };
11 int getVelocidad() const { return velocidad; };
12 };
Listado 11.2.2. Armamento.h

1 class Nave : public Armamento{

2 private:
3 int cohetes;
4 public:
5 Nave(int b, int vi, int v, int c):
6 Armamento(b,vi,v), cohetes(c){};
7 int getCohetes() const { return cohetes; };
8 };
Listado 11.2.3. Nave.h

Autor: Francisco J. Arce A. página 146/180 [Link]

 Introducción a C++

1 class Tanque : public Armamento{

2 private:
3 int lanzaLlamas;
4 public:
5 Tanque(int b, int vi, int v, int l):
6 Armamento(b,vi,v), lanzaLlamas(l){};
7 int getLanzaLlamas() const { return lanzaLlamas; };
8 };
Listado 11.2.4. Tanque.h

Autor: Francisco J. Arce A. página 147/180 [Link]

 Introducción a C++

11.3. Llamar a un método de otra clase

● Podemos llamar a las funciones miembro de una clase por otra clase sin necesidad de la herencia.
● Necesitamos declarar dentro de la clase la instancia de la segunda clase.

1 #include <iostream>
2 using namespace std;
3 /*
4 Herencia: llamar a un método de otra clase
5 */
6 class Nave{
7 private:
8 int balas;
9
10 public:
11 Nave(int b):balas(b){
12 cout << "Constructor de la Nave" << endl;
13 }
14 int getBalas() const { return balas; }
15 };
16 class Tanque{
17 private:
18 int vidas;
19 Nave NaveBalas;
20
21 public:
22 Tanque(int b, int v):NaveBalas(b),vidas(v){
23 cout << "Constructor del Tanque" << endl;
24 }
25 int getBalas() const { return [Link](); }
26 int getVidas() const { return vidas; }
27 };
28 int main()
29 {
30 Tanque tanque1(15,3);
31
32 cout << "Balas " << [Link]() <<
33 ", vidas " << [Link]() << endl;
34
35 return 0;
36 }
Listado 11.3.1. [Link]

Autor: Francisco J. Arce A. página 148/180 [Link]

 Introducción a C++

11.4. Destructores de clases derivadas

Cuando se invoca una función destructora de una clase derivada, primero se ejecuta la función
destructora de la clase derivada, y luego la función destructora de la clase base y así
sucesivamente en la jerarquía de la herencia.

1 #include <iostream>
2 using namespace std;
3 /*
4 Herencia: llamar a las funciones destructoras
5 */
6 class Nave{
7 private:
8 int balas;
9
10 public:
11 Nave(int b):balas(b){
12 cout << "Constructor de la Nave" << endl;
13 }
14 ~Nave(){ cout << "Destruimos la nave..." << endl; }
15 int getBalas() const { return balas; }
16 };
17 class Tanque{
18 private:
19 int vidas;
20 Nave NaveBalas;
21
22 public:
23 Tanque(int b, int v):NaveBalas(b),vidas(v){
24 cout << "Constructor del Tanque" << endl;
25 }
26 ~Tanque(){ cout << "Destruimos el tanque..." << endl; }
27 int getBalas() const { return [Link](); }
28 int getVidas() const { return vidas; }
29 };
30 int main()
31 {
32 Tanque tanque1(15,3);
33
34 cout << "Balas " << [Link]() <<
35 ", vidas " << [Link]() << endl;
36
37 return 0;
38 }
Listado 11.4.1. [Link]

Autor: Francisco J. Arce A. página 149/180 [Link]

 Introducción a C++

11.5. Sobre escribir u overriding un método

● Cuando heredamos métodos en la clase derivada, podemos sobreescribir los métodos u overriding.
● El método de la clase base se “oculta”.
● Podemos llamar a la clase “oculta” mediante su nombre completo.

1 #include <iostream>
2 using namespace std;
3 /*
4 Herencia: llamar a las funciones destructoras
5 */
6 class Nave{
7 private:
8 int balas;
9
10 public:
11 Nave(int b):balas(b){
12 cout << "Constructor de la Nave" << endl;
13 }
14 ~Nave(){ cout << "Destruimos la nave..." << endl; }
15 int getBalas() const { return balas; }
16 void mostrar(){
17 cout << "Numero de balas: " << balas << endl;
18 }
19 };
20 class Tanque : public Nave{
21 private:
22 int vidas;
23
24 public:
25 Tanque(int b, int v):Nave(b),vidas(v){
26 cout << "Constructor del Tanque" << endl;
27 }
28 ~Tanque(){ cout << "Destruimos el tanque..." << endl; }
29 int getVidas() const { return vidas; }
30 void mostrar(){
31 cout << "Numero de balas: " << getBalas() << endl;
32 cout << "Numero de vidas: " << vidas << endl;
33 }
34 };
35 int main()
36 {
37 Tanque tanque1(15,3);
38
39 cout << "Llamamos a la función desde tanque" << endl;
40 [Link]();
41
42 cout << endl << "Llamamos a la función desde nave" << endl;

Autor: Francisco J. Arce A. página 150/180 [Link]

 Introducción a C++
43 [Link]::mostrar();
44
45 return 0;
46 }
Listado 11.5.1. [Link]

Autor: Francisco J. Arce A. página 151/180 [Link]

 Introducción a C++

11.6. Overriding y la sobrecarga

● Cuando heredamos métodos en la clase derivada, podemos sobreescribir los métodos u overriding.
● El método de la clase base se “oculta”, asi como los métodos sobrecargados correspondientes.
● Podemos llamar a la clase “oculta” mediante su nombre completo, así como a cualquier método sobregargado
“oculto”.

1 #include <iostream>
2 using namespace std;
3 /*
4 Herencia: overriding y sobrecargados
5 */
6 class Nave{
7 public:
8 void avanzar() { cout << "Avanzamos un km." << endl;}
9 void avanzar(int k) { cout << "Avanzamos " << k << " km." << endl;}
10 };
11 class Tanque : public Nave{
12 public:
13 void avanzar() { cout << "El tanque avanza 2 km." << endl; }
14 };
15 int main()
16 {
17 Tanque tanque1;
18
19 [Link]();
20 [Link]::avanzar();
21 [Link]::avanzar(7);
22
23 return 0;
24 }
Listado 11.6.1. [Link]

Autor: Francisco J. Arce A. página 152/180 [Link]

 Introducción a C++

11.7. Herencia múltiple

● Podemos crear una clase derivada a partir de muchas clases base.
● A eso lo conoceremos como herencia múltiple.
● Las clases derivadas heredan todas las propiedades y métodos permitidos de las clases base.

1 #include <iostream>
2 using namespace std;
3 /*
4 Herencia multiple
5 */
6 class Nave{
7 public:
8 Nave() : balas(10) {};
9 int mostrar() const { return balas;}
10 protected:
11 int balas;
12 };
13 class Coordenadas{
14 public:
15 Coordenadas() : posX(20), posY(30) {};
16 int mostrar() const { return posX;}
17 protected:
18 int posX, posY;
19 };
20 class Tanque: public Nave, public Coordenadas{
21 public:
22 int mostrar() const { return Nave::mostrar(); }
23 };
24 int main()
25 {
26 Tanque tanque1;
27
28 //Un problema de ambiguedad
29 //cout << "Balas: " << [Link]::mostrar() << endl;
30 //cout << "Pos x: " << [Link]::mostrar() << endl;
31
32 cout << "Balas: " << [Link]() << endl;
33
34 return 0;
35 }
Listado 11.7.1. [Link]

Autor: Francisco J. Arce A. página 153/180 [Link]

 Introducción a C++

11.8. Los constructores en la herencia múltiple

Cuando creamos una clase con herencia múltiple podemos llamar los constructores de las
clases base dentro de la clase derivada.

1 #include <iostream>
2 using namespace std;
3 /* Herencia constructores */
4 class Nave{
5 public:
6 Nave() : balas(10) {};
7 Nave(int b) : balas(b) {};
8 int mostrar() const { return balas;}
9 protected:
10 int balas;
11 };
12 class Coordenadas{
13 public:
14 Coordenadas() : posX(20), posY(30) {};
15 Coordenadas(int xx, int yy) : posX(xx), posY(yy) {};
16 void mostrar() const {
17 cout << "Coordenadas: " << posX << "," << posY << endl;
18 }
19 protected:
20 int posX, posY;
21 };
22 /*** Clase derivada ****/
23 class Tanque: public Nave, public Coordenadas{
24 public:
25 Tanque(int b, int x, int y) : Nave(b), Coordenadas(x,y) {};
26 int mostrarBalas() const { return Nave::mostrar(); }
27 void mostrarCoordenadas() const { Coordenadas::mostrar(); }
28 private:
29 int x,y,b;
30 };
31 int main()
32 {
33 Tanque tanque1(100,40,50);
34 //Un problema de ambiguedad
35 //cout << "Balas: " << [Link]::mostrar() << endl;
36 //cout << "Pos x: " << [Link]::mostrar() << endl;
37 cout << "Balas: " << [Link]() << endl;
38 [Link]();
39 return 0;
40 }
Listado 11.8.1. [Link]

Autor: Francisco J. Arce A. página 154/180 [Link]

 Introducción a C++

11.9. Herencia virtual

● Cuando tenemos herencia múltiple, es posible que una clase se repita dentro de la jerarquía de herencias, con la
cual el compilador marcará un problema de ambigüedad.
● Para ello, debemos marcar a la clase que se repite como “virtual”.
● Observe el siguiente ejemplo:

1 #include <iostream>
2 using namespace std;
3 /* Herencia virtual */
4 class Mamifero{
5 public:
6 Mamifero(string n) : nombre(n) {}
7 string getNombre() const { return nombre;}
8 protected:
9 string nombre;
10 };
11 class Caballo : virtual public Mamifero{
12 public:
13 Caballo(string n, int p) : Mamifero(n), peso(p) {}
14 int getPeso() const { return peso;}
15 void setPeso(int p){peso = p;}
16 protected:
17 int peso;
18 };
19 class Burro : virtual public Mamifero{
20 public:
21 Burro(string n, int e) : Mamifero(n), edad(e) {}
22 int getEdad() const { return edad;}
23 void setEdad(int e){edad = e;}
24 protected:
25 int edad;
26 };
27 class Mula : public Caballo, public Burro{
28 public:
29 Mula(string n, int p, int e):
30 Mamifero(n), Caballo(n, p), Burro(n, e) {}
31 };
32 int main()
33 {
34 Mula mula1("Maicera", 100, 15);
35 cout << "Nombre de la mula: " << [Link]() << ", "
36 << "Peso " << [Link]() << " kilos, "
37 << "Edad: " << [Link]() << " anios" << endl;
38 return 0;
39 }
Listado 11.9.1. [Link]

Autor: Francisco J. Arce A. página 155/180 [Link]

 Introducción a C++

11.10. Enlaces o ligaduras

● Tiempo de autor
● Tiempo de compilación
● Tiempo de ejecución

● Enlaces o ligaduras: es cuando el compilador relaciona un identificador con su contenido. Si es una función, sería
el nombre de la función con su código, si es una variable, relacionar su contenido con su valor.
● Cuando el compilador realiza el enlace o ligadura, se le conoce como “tiempo de ligadura o enlace”.
● Si la ligadura se realiza en “tiempos de compilación”, se le conoce como ligadura estática o enlace estático.
● Si la ligadura se realiza en “tiempo de ejecución” se le conoce como ligadura dinámica o enlace dinámico.
● En lenguajes como Java, PHP, Eiffel, SmallTalk los enlaces siempre son dinámicos.
● En C# y C++ los enlaces son estáticos, pero el programador puede hacerlos dinámicos.
● En C++ hacemos un enlace dinámico con la palabra reservada virtual.
● Necesitamos utilizar a las referencias de las clases como apuntadores o referencias.
● Las funciones virtuales deben declarar como virtual en la clase primer clase en la que están presente.

1 #include <iostream>
2 using namespace std;
3 /*
4 Ligadura estatica
5 */
6 class Mamifero{
7 public:
8 Mamifero(string n) : nombre(n) {}
9 string getNombre() const { return nombre;}
10 void setNombre() {
11 cout << "Mamifero: " << nombre << endl;
12 }
13 protected:
14 string nombre;
15 };
16 class Caballo : virtual public Mamifero{
17 public:
18 Caballo(string n, int p) : Mamifero(n), peso(p) {}
19 int getPeso() const { return peso;}
20 void setPeso(int p){peso = p;}
21 void setNombre() {
22 cout << "Caballo: " << nombre << endl;
23 }
24 protected:
25 int peso;
26 };
27 class Burro : virtual public Mamifero{
28 public:
29 Burro(string n, int e) : Mamifero(n), edad(e) {}
30 int getEdad() const { return edad;}
31 void setEdad(int e){edad = e;}
32 void setNombre() {

Autor: Francisco J. Arce A. página 156/180 [Link]

 Introducción a C++
33 cout << "Burro: " << nombre << endl;
34 }
35 protected:
36 int edad;
37 };
38 int main()
39 {
40 Mamifero *caballo1 = new Caballo("Mrs. Ed",100);
41 Mamifero *burro1 = new Burro("Paco",12);
42
43 caballo1 -> setNombre();
44 burro1 -> setNombre();
45
46 delete caballo1;
47 delete burro1;
48 return 0;
49 }
Listado 11.10.1. [Link]

Autor: Francisco J. Arce A. página 157/180 [Link]

 Introducción a C++

11.11. Funciones virtuales

● Funciones virtuales: Por medio del modificador virtual podemos indicarle al compilador que realiza el ligado de las
funciones en tiempo de ejecución, no en tiempo de compilación, es decir que el ligado sea dinámico.
● El modificador virtual solo se utiliza la primera vez que aparece la función dentro de la jerarquía de clases.
● Cuando declaramos una función como virtual, y existe una sobreposición u overriding en una función en una clase
derivada, al invocar la función de la clase base, se ejecutará la versión de la clase derivada.

1 #include <iostream>
2 using namespace std;
3 /*
4 Ligadura estatica
5 */
6 class Mamifero{
7 public:
8 Mamifero(string n) : nombre(n) {}
9 string getNombre() const { return nombre;}
10 virtual void setNombre() {
11 cout << "Mamifero: " << nombre << endl;
12 }
13 protected:
14 string nombre;
15 };
16 class Caballo : virtual public Mamifero{
17 public:
18 Caballo(string n, int p) : Mamifero(n), peso(p) {}
19 int getPeso() const { return peso;}
20 void setPeso(int p){peso = p;}
21 void setNombre() {
22 cout << "Caballo: " << nombre << endl;
23 }
24 protected:
25 int peso;
26 };
27 class Burro : virtual public Mamifero{
28 public:
29 Burro(string n, int e) : Mamifero(n), edad(e) {}
30 int getEdad() const { return edad;}
31 void setEdad(int e){edad = e;}
32 void setNombre() {
33 cout << "Burro: " << nombre << endl;
34 }
35 protected:
36 int edad;
37 };
38 int main()
39 {
40 Mamifero *caballo1 = new Caballo("Mrs. Ed",100);
41 Mamifero *burro1 = new Burro("Paco",12);

Autor: Francisco J. Arce A. página 158/180 [Link]

 Introducción a C++
42
43 caballo1 -> setNombre();
44 burro1 -> setNombre();
45
46 delete caballo1;
47 delete burro1;
48 return 0;
49 }
Listado 11.11.1. [Link]

Autor: Francisco J. Arce A. página 159/180 [Link]

 Introducción a C++

11.12. Polimorfismo
● Polimorfismo: Podemos llamar a una función miembro en objetos diferentes, llamarse igual y hacer cosas
diferentes.
● Las funciones virtuales se declaran en la clase base.
● Las implementaciones específicas de las funciones virtuales se realizan en las clases derivadas.
● Las instancias de las clases se deben utilizar como apuntadores o referencias.

1 #include <iostream>
2 using namespace std;
3 /*
4 Polimorfismo
5 */
6 class Mamifero{
7 public:
8 Mamifero(string n):nombre(n){}
9 virtual void hablar(){
10 cout << nombre << " el mamifero dice jajaja" << endl;
11 }
12 protected:
13 string nombre;
14 };
15 class Gato : public Mamifero{
16 public:
17 Gato(string n):Mamifero(n){}
18 void hablar(){
19 cout << nombre << " el gato dice miau, miau" << endl;
20 }
21 };
22 class Perro : public Mamifero{
23 public:
24 Perro(string n):Mamifero(n){}
25 void hablar(){
26 cout << nombre << " el perro dice guau, guau" << endl;
27 }
28 };
29 class Humano : public Mamifero{
30 public:
31 Humano(string n):Mamifero(n){}
32 void hablar(){
33 cout << nombre << " el humano dice bla, bla, bla" << endl;
34 }
35 };
36 int main()
37 {
38 Humano humano("Pepe");
39 Gato gato("Cucho");
40 Perro perro("Fido");
41 //Referencias

Autor: Francisco J. Arce A. página 160/180 [Link]

 Introducción a C++
42 Mamifero &ptrHumano = humano;
43 Mamifero &ptrGato = gato;
44 Mamifero &ptrPerro = perro;
45 //llamar a la funcion
46 [Link]();
47 [Link]();
48 [Link]();
49
50 return 0;
51 }
Listado 11.12.1. [Link]

Autor: Francisco J. Arce A. página 161/180 [Link]

 Introducción a C++
Los fundamentos del lenguaje
Capítulo 12: Funciones y clases con plantillas o templates
Objetivo: El alumno creará funciones y clases por medio de plantillas.

Introducción:
En esta sección estudiaremos:
● Plantillas o templates
● Tipos de datos
● Plantillas en archivo de encabezados
● Plantillas y arreglos
● Plantillas de clases
● Plantillas en archivos de encabezado
● Crear una clase Pila
● Clases plantilla con clases
 Introducción a C++

12.1. Plantillas o templates

● Un problema frecuente en la programación del lenguaje C++ es tener que repetir una función para tipos de datos
diferentes.
● Una posible solución es el uso de funciones sobrecargadas, pero hay que darles mantenimiento a cada uno de
las funciones para cada uno de los tipos de datos.
● La mejor opción es el uso de plantillas (templates o patrones) propuestas por Stroustrup en 1988.
● Podemos tener plantillas para funciones y para clases.

1 #include <iostream>
2 using namespace std;
3 /*
4 Plantillas
5 */
6 template <typename T>
7 void intercambiar(T &v1, T &v2){
8 T temp;
9 temp = v1;
10 v1 = v2;
11 v2 = temp;
12 }
13 int main()
14 {
15 int num1 = 6, num2 = 10;
16 cout << "Numeros originales " << num1 << ", "
17 << num2 << endl;
18 intercambiar(num1,num2);
19 cout << "Numeros intercambiados " << num1 << ", "
20 << num2 << endl;
21 cout << "----------------" << endl;
22
23 char car1 = 'Z', car2 = 'A';
24 cout << "Caracteres originales " << car1 << ", "
25 << car2 << endl;
26 intercambiar(car1,car2);
27 cout << "Caracteres intercambiados " << car1 << ", "
28 << car2 << endl;
29
30 return 0;
31 }
Listado 12.1.1. [Link]

Autor: Francisco J. Arce A. página 163/180 [Link]

 Introducción a C++

12.2. Tipos de datos en las plantillas

Cada parámetro tiene que requiere una palabra reservada class o typename.
Podemos hacer varias combinaciones con los tipos definidos y tipos regulares de C++.
Podemos hacer varios tipos definidos siempre y cuando los tipos recibidos sean diferentes.
Podemos utilizar apuntadores (*) o referencia (&).
● template <class T> T & f(T parámetro){}
● template <class T> T f(int x, T parámetro){}
● template <class T> T f(T x, T y){}
● template <class T1, class T2> T1 f(T1 x, T2 y){}

1 #include <iostream>
2 using namespace std;
3 /*
4 Plantillas parámetros
5 */
6 template <typename T>
7 string comparar(T v1, T v2){
8 if(v1 < v2) return "es menor";
9 if(v1 > v2) return "es mayor";
10 return "son iguales";
11 }
12 int main()
13 {
14 int num1=10, num2=15;
15 cout << "El numero " << num1 << " es "
16 << comparar(num1,num2) << " que " << num2 << endl;
17 cout << "--------------------------" << endl;
18
19 char car1='X', car2='B';
20 cout << "El caracter " << car1 << " es "
21 << comparar(car1,car2) << " que " << car2 << endl;
22 cout << "--------------------------" << endl;
23
24 float f1=1234.567, f2=8765.4321;
25 cout << "El numero " << f1 << " es "
26 << comparar(f1,f2) << " que " << f2 << endl;
27 cout << "--------------------------" << endl;
28
29 return 0;
30 }
Listado 12.2.1. [Link]

Autor: Francisco J. Arce A. página 164/180 [Link]

 Introducción a C++

12.3. Plantillas en archivo de encabezados

● Podemos guardar las funciones de plantilla en un archivo de encabezado.
● Es recomendable utilizar las directivas del compilador (o precompilador) como #ifndef y #endif que evitarían que
fueran definidos dos veces las funciones.

1 #include <iostream>
2 #include "MinMax.h"
3 using namespace std;
4 /* Plantillas parámetros */
5 int main()
6 {
7 int n1=123, n2= 345;
8 double d1 = 123.456, d2=345.321;
9
10 cout << "El numero entero mayor entre " << n1
11 << " y " << n2 << " es " << maximo(n1,n2) << endl;
12 cout << "El numero entero menor entre " << n1
13 << " y " << n2 << " es " << minimo(n1,n2) << endl;
14 cout << "------------------" << endl;
15
16 cout << "El numero doble mayor entre " << d1
17 << " y " << d2 << " es " << maximo(d1,d2) << endl;
18 cout << "El numero doble menor entre " << d1
19 << " y " << d2 << " es " << minimo(d1,d2) << endl;
20 cout << "------------------" << endl;
21 return 0;
22 }
Listado 12.3.1. [Link]

1 #ifndef _MAXMIN_
2 #define _MAXMIN_
3
4 template <typename T>
5 T maximo(T a, T b){ return (a>b)? a : b; }
6 template <typename T>
7 T minimo(T a, T b){ return (a<b)? a : b; }
8 #endif
Listado 12.3.2. MinMax.h

Autor: Francisco J. Arce A. página 165/180 [Link]

 Introducción a C++

12.4. Plantillas y arreglos

● El nombre de un arreglo es en realidad un apuntador.
● Podemos utilizarlo desde una plantilla si nos dicen el número de datos del mismo.

1 #include <iostream>
2 #include <cstdlib>
3 #include <ctime>
4 using namespace std;
5
6 #define MAX 100
7 #define randomize (srand(time(NULL)))
8 #define random(num) (rand()%num)
9
10 template <typename T> void intercambiar(T &v1, T &v2){
11 T temp;
12 temp = v1;
13 v1 = v2;
14 v2 = temp;
15 }
16 template <typename T> void ordenar(T *v, int n){
17 for (int intervalo = n/2; intervalo > 0; intervalo /= 2){
18 for (int i = intervalo; i < n; i++)
19 {
20 for (int j = i-intervalo; j>=0 && v[j+intervalo]<v[j];j-=intervalo)
21 {
22 intercambiar(v[j],v[j+intervalo]);
23 }
24 }
25 }
26 }
27 /*
28 Plantillas parámetros
29 */
30 int main()
31 {
32 int i, enteros[10];
33 string dias[7] = {"Lunes", "Martes", "Miercoles",
34 "Jueves", "Viernes", "Sabado", "Domingo"};
35
36 randomize;
37 cout << "Antes de ordenar" << endl;
38 for (i = 0; i < 10; ++i)
39 {
40 enteros[i] = random(MAX);
41 cout << enteros[i] << " ";
42 }
43

Autor: Francisco J. Arce A. página 166/180 [Link]

 Introducción a C++
44 cout << endl << "----------------" << endl;
45 ordenar(enteros,10);
46
47 cout << "Despues de ordenar" << endl;
48 for (i = 0; i < 10; ++i)
49 {
50 cout << enteros[i] << " ";
51 }
52
53 cout << endl << "----------------" << endl;
54
55 cout << "Antes de ordenar" << endl;
56 for (i = 0; i < 7; ++i)
57 {
58 cout << dias[i] << " ";
59 }
60
61 cout << endl << "----------------" << endl;
62 ordenar(dias,7);
63
64 cout << "Despues de ordenar" << endl;
65 for (i = 0; i < 7; ++i)
66 {
67 cout << dias[i] << " ";
68 }
69
70 cout << endl << "----------------" << endl;
71
72
73 return 0;
74 }
Listado 12.4.1. [Link]

Autor: Francisco J. Arce A. página 167/180 [Link]

 Introducción a C++

12.5. Plantillas de clases

● Por medio de las plantillas podemos clases que manipulen diferentes tipos de datos.
● También se les conoce como clases parametrizables.
● La sintaxis de una plantilla de clase es:

template <class nombreTipo> class nombreClass{

//sentencias
}
● Para utilizar la clase hay que definir bajo qué tipo queremos utilizarla.

nombreClase <tipoDato> nombreInstancia;

1 #include <iostream>
2 using namespace std;
3 /*Plantillas clases*/
4 template <class T> class MaxMin{
5 private:
6 T n1,n2;
7 public:
8 MaxMin(T v1, T v2):n1(v1), n2(v2) {}
9 T mayor();
10 T menor();
11 };
12 template <class T>
13 T MaxMin<T>::mayor(){ return (n1>n2)? n1:n2; }
14
15 template <class T>
16 T MaxMin<T>::menor(){ return (n1<n2)? n1:n2; }
17
18 int main()
19 {
20 MaxMin<int> miMaxMin(43,50);
21 MaxMin<float> floatMaxMin(1234.5678,6543.321);
22
23 cout << "El numero mayor es " << [Link]() << endl;
24 cout << "El numero menor es " << [Link]() << endl;
25 cout << "----------------------------" << endl;
26 cout << "El numero mayor es " << [Link]() << endl;
27 cout << "El numero menor es " << [Link]() << endl;
28 cout << "----------------------------" << endl;
29 return 0;
30 }
Listado 12.5.1. [Link]

Autor: Francisco J. Arce A. página 168/180 [Link]

 Introducción a C++

12.6. Plantillas en archivos de encabezado

● Una pila (o stack) es una estructura de datos que los últimos datos que entran, son los primeros que salen (Last
In, First Out), Últimas entradas, primeras salidas (LIFO).
● Tiene dos funciones básicas: push() introduce los datos y pop() saca un dato de la pila.

1 #include <iostream>
2 #include "Pila.h"
3 using namespace std;
4 /*
5 Plantillas archivos de encabezado
6 */
7
8 int main()
9 {
10 Pila <int> pilaEnteros(10);
11
12 [Link](90);
13 [Link](77);
14 [Link](10);
15
16 cout << "Numero de elementos: " << [Link]() << endl;
17
18 cout << "Eliminamos el elemento " << [Link]()
19 << " de la pila" << endl;
20 cout << "Eliminamos el elemento " << [Link]()
21 << " de la pila" << endl;
22 cout << "Eliminamos el elemento " << [Link]()
23 << " de la pila" << endl;
24
25 cout << "Numero de elementos: " << [Link]() << endl;
26 return 0;
27 }
Listado 12.6.1. [Link]

1 #ifndef _PILA_
2 #define _PILA_
3 template <class T>
4 class Pila{
5 public:
6 Pila();
7 Pila(const unsigned n);
8 ~Pila();
9 void push(const T &x);
10 T pop();
11 int numElementos();
12 private:
13 unsigned max;

Autor: Francisco J. Arce A. página 169/180 [Link]

 Introducción a C++
14 unsigned top;
15 T *valor;
16 };
17 /* Implementacion */
18 template <class T>
19 Pila<T>::Pila(): max(100), top(0), valor(new T[max]){}
20
21 template <class T>
22 Pila<T>::Pila(const unsigned n):
23 max(n), top(0), valor(new T[max]){}
24
25 template <class T>
26 Pila<T>::~Pila(){
27 delete []valor;
28 }
29
30 template <class T>
31 void Pila<T>::push(const T &x){
32 valor[top++] = x;
33 }
34
35 template <class T>
36 T Pila<T>::pop(){
37 return valor[--top];
38 }
39
40 template <class T>
41 int Pila<T>::numElementos(){
42 return top;
43 }
44 #endif
Listado 12.6.2. Pila.h

Autor: Francisco J. Arce A. página 170/180 [Link]

 Introducción a C++

12.7. Crear una clase Pila

Concluiremos las pruebas de la pila con otros tipos de datos

1 #include <iostream>
2 #include "Pila.h"
3 using namespace std;
4 /*
5 Plantillas archivos de encabezado
6 */
7
8 int main()
9 {
10 Pila <int> pilaEnteros(10);
11
12 [Link](90);
13 [Link](77);
14 [Link](10);
15
16 cout << "Numero de elementos: " << [Link]() << endl;
17
18 cout << "Eliminamos el elemento " << [Link]()
19 << " de la pila" << endl;
20 cout << "Eliminamos el elemento " << [Link]()
21 << " de la pila" << endl;
22 cout << "Eliminamos el elemento " << [Link]()
23 << " de la pila" << endl;
24
25 cout << "Numero de elementos: " << [Link]() << endl;
26
27 cout << "-------------------" << endl;
28
29 Pila <double> pilaDobles(10);
30
31 [Link](90.99);
32 [Link](100.77);
33 [Link](234.10);
34
35 cout << "Numero de elementos: " << [Link]() << endl;
36
37 cout << "Eliminamos el elemento " << [Link]()
38 << " de la pila" << endl;
39 cout << "Eliminamos el elemento " << [Link]()
40 << " de la pila" << endl;
41 cout << "Eliminamos el elemento " << [Link]()
42 << " de la pila" << endl;
43
44 cout << "Numero de elementos: " << [Link]() << endl;
45
46 cout << "-------------------" << endl;

Autor: Francisco J. Arce A. página 171/180 [Link]

 Introducción a C++
47
48 Pila <long> pilaLargos(10);
49
50 [Link](1234363L);
51 [Link](8678484L);
52 [Link](5356535L);
53
54 cout << "Numero de elementos: " << [Link]() << endl;
55
56 cout << "Eliminamos el elemento " << [Link]()
57 << " de la pila" << endl;
58 cout << "Eliminamos el elemento " << [Link]()
59 << " de la pila" << endl;
60 cout << "Eliminamos el elemento " << [Link]()
61 << " de la pila" << endl;
62
63 cout << "Numero de elementos: " << [Link]() << endl;
64 return 0;
65 }
Listado 12.7.1. [Link]

1 #ifndef _PILA_
2 #define _PILA_
3 template <class T>
4 class Pila{
5 public:
6 Pila();
7 Pila(const unsigned n);
8 ~Pila();
9 void push(const T &x);
10 T pop();
11 int numElementos();
12 void mostrar();
13 private:
14 unsigned max;
15 unsigned top;
16 T *valor;
17 };
18 /* Implementacion */
19 template <class T>
20 Pila<T>::Pila(): max(100), top(0), valor(new T[max]){}
21
22 template <class T>
23 Pila<T>::Pila(const unsigned n):
24 max(n), top(0), valor(new T[max]){}
25
26 template <class T>
27 Pila<T>::~Pila(){
28 delete []valor;
29 }
30

Autor: Francisco J. Arce A. página 172/180 [Link]

 Introducción a C++
31 template <class T>
32 void Pila<T>::push(const T &x){
33 valor[top++] = x;
34 }
35
36 template <class T>
37 T Pila<T>::pop(){
38 return valor[--top];
39 }
40
41 template <class T>
42 int Pila<T>::numElementos(){
43 return top;
44 }
45 #endif
Listado 12.7.2. Pila.h

Autor: Francisco J. Arce A. página 173/180 [Link]

 Introducción a C++

12.8. Clases plantilla con clases

● Una clase de plantilla se puede instanciar con cualquier tipo de dato.
● Podemos instanciar cualquier clase.

1 #include <iostream>
2 #include "Pila.h"
3 #include "Complejo.h"
4 using namespace std;
5 /*
6 Plantillas archivos de encabezado
7 */
8
9 int main()
10 {
11 Pila <Complejo> pilaComplejos(10);
12 Complejo complejo;
13
14 [Link](Complejo(20,40));
15 [Link](Complejo(10,-40));
16 [Link](Complejo(30,-90));
17
18 cout << "Numero de elementos " << [Link]()
19 << endl;
20
21 complejo = [Link]();
22 cout << "Eliminamos el elemento " << [Link]() << ","
23 << [Link]() << " de la pila." << endl;
24
25 complejo = [Link]();
26 cout << "Eliminamos el elemento " << [Link]() << ","
27 << [Link]() << " de la pila." << endl;
28
29 complejo = [Link]();
30 cout << "Eliminamos el elemento " << [Link]() << ","
31 << [Link]() << " de la pila." << endl;
32
33 cout << "Numero de elementos " << [Link]()
34 << endl;
35
36 return 0;
37 }
Listado 12.8.1. [Link]

1 #ifndef _PILA_
2 #define _PILA_
3 template <class T>
4 class Pila{

Autor: Francisco J. Arce A. página 174/180 [Link]

 Introducción a C++
5 public:
6 Pila();
7 Pila(const unsigned n);
8 ~Pila();
9 void push(const T &x);
10 T pop();
11 int numElementos();
12 void mostrar();
13 private:
14 unsigned max;
15 unsigned top;
16 T *valor;
17 };
18 /* Implementacion */
19 template <class T>
20 Pila<T>::Pila(): max(100), top(0), valor(new T[max]){}
21
22 template <class T>
23 Pila<T>::Pila(const unsigned n):
24 max(n), top(0), valor(new T[max]){}
25
26 template <class T>
27 Pila<T>::~Pila(){
28 delete []valor;
29 }
30
31 template <class T>
32 void Pila<T>::push(const T &x){
33 valor[top++] = x;
34 }
35
36 template <class T>
37 T Pila<T>::pop(){
38 return valor[--top];
39 }
40
41 template <class T>
42 int Pila<T>::numElementos(){
43 return top;
44 }
45 #endif
Listado 12.8.2. Pila.h

1 class Complejo{
2 public:
3 Complejo(const double r=0, const double i=0):
4 real(r), imaginario(i) {};
5 double getR() const;
6 double getI() const;
7 void setR(const double);
8 void setI(const double);

Autor: Francisco J. Arce A. página 175/180 [Link]

 Introducción a C++
9 private:
10 double real, imaginario;
11 };
12 /* Implementacion */
13 double Complejo::getR() const{
14 return real;
15 }
16 double Complejo::getI() const{
17 return imaginario;
18 }
19 void Complejo::setR(const double r){
20 real = r;
21 }
22 void Complejo::setI(const double i){
23 imaginario = i;
24 }
Listado 12.8.3. Complejo.h

Autor: Francisco J. Arce A. página 176/180 [Link]

 Introducción a C++

Indice

Capítulo 1: Introducción a C++ ............................................................................................... p. 3

1.1. Introducción a C++ .................................................................................................... p. 4
1.2. Instalar el compilador en Windows 7 ........................................................................ p. 5
1.3. Instalar el compilador en Windows 10 ...................................................................... p. 6
1.4. Estructura de un programa ....................................................................................... p. 7
1.5. Los espacios de nombres ......................................................................................... p. 8
1.6. Los tipos de datos nativos en C++ ............................................................................ p. 9
1.7. Tipos reales o coma flotante ..................................................................................... p. 11
1.8. Las Literales en el Lenguaje C++ ............................................................................. p. 12
1.9. Tipo apuntadores ...................................................................................................... p. 13
1.10. Constantes en el lenguaje C++ ............................................................................... p. 14
1.11. Tipos de datos: referencias ..................................................................................... p. 15
1.12. Tipos definidos: typedef .......................................................................................... p. 16
1.13. Tipo de datos: Enumeraciones ............................................................................... p. 17
1.14. Tipo de datos: Arreglos ........................................................................................... p. 18
1.15. Tipo de dato: Caracteres ......................................................................................... p. 19
1.16. Tipo de dato: Cadenas o strings ............................................................................. p. 20
1.17. Tipo de dato: Booleanos ......................................................................................... p. 21
1.18. Las variables en el Lenguaje C++ ........................................................................... p. 22
Capítulo 2: Expresiones y operadores en el lenguaje C++ ..................................................... p. 23
2.1. Operadores matemáticos o aritméticos .................................................................... p. 24
2.2. Operadores relacionales ........................................................................................... p. 25
2.3. Operadores de asignación ........................................................................................ p. 26
2.4. Operadores de incremento y decremento ................................................................. p. 27
2.5. Operadores lógicos ................................................................................................... p. 28
2.6. El operador condicional ............................................................................................. p. 31
2.7. El operador coma ...................................................................................................... p. 32
2.8. Operadores de bits .................................................................................................... p. 33
2.9. Operador sizeof() ...................................................................................................... p. 34
2.10. Conversión de tipos ................................................................................................ p. 35
2.11. Operador new ......................................................................................................... p. 37
Capítulo 3: Estructuras condicionales lenguaje C++ .............................................................. p. 38
3.1. La sentencia if ........................................................................................................... p. 39
3.2. La sentencia if-else ................................................................................................... p. 41
3.3. Sentencias if anidadas .............................................................................................. p. 42

Autor: Francisco J. Arce A. página 177/180 [Link]

 Introducción a C++
3.4. Sentencias else-if ...................................................................................................... p. 43
3.5. La sentencia switch ................................................................................................... p. 44
3.6. Operador condicional ................................................................................................ p. 46
Capítulo 4: Estructuras cíclicas en el lenguaje C++ ................................................................ p. 47
4.1. La estructura while() .................................................................................................. p. 48
4.2. La estructura do..while() ............................................................................................ p. 49
4.3. El ciclo for() ............................................................................................................... p. 51
4.4. Las sentencias break y continue ............................................................................... p. 53
4.5. Ciclos anidados ......................................................................................................... p. 54
4.6. Ciclos, enumeraciones y sentencias nulas ............................................................... p. 55
Capítulo 5: Funciones en el lenguaje C++ .............................................................................. p. 56
5.1. Fundamentos de las funciones creadas por el usuario ............................................. p. 57
5.2. Crear prototipos ........................................................................................................ p. 58
5.3. Parámetros múltiples en una función ........................................................................ p. 59
5.4. Pasar parámetros por valor o por referencia ............................................................ p. 61
5.5. Funciones en línea .................................................................................................... p. 62
5.6. Valores por defecto ................................................................................................... p. 63
5.7. Apuntadores como parámetros ................................................................................. p. 64
5.8. Arreglos como parámetros ........................................................................................ p. 65
5.9. Arreglos de varias dimensiones como parámetros ................................................... p. 66
5.10. Regresar una referencia ......................................................................................... p. 67
5.11. Funciones recursivas .............................................................................................. p. 68
5.12. Argumentos de la función main() ............................................................................ p. 69
5.13. Las funciones sobrecargadas ................................................................................. p. 70
5.14. Funciones apuntadas .............................................................................................. p. 72
Capítulo 6: Funciones Librerias ANSI C ................................................................................. p. 74
6.1. Funciones aleatorias ................................................................................................. p. 75
6.2. Ejemplo funciones aleatorias .................................................................................... p. 76
6.3. Desordenar un arreglo .............................................................................................. p. 77
6.4. Funciones utilitarias .................................................................................................. p. 78
6.5. Funciones matemáticas ............................................................................................ p. 79
6.6. Funciones trigonométricas ........................................................................................ p. 80
6.7. Funciones de tiempo ................................................................................................. p. 81
6.8. Funciones de tiempo: UTC ....................................................................................... p. 82
6.9. Funciones para cadenas ........................................................................................... p. 84
6.10. Funciones para cadenas: strtok .............................................................................. p. 86
6.11. Funciones de entrada ............................................................................................. p. 87
Capítulo 7: Estructuras y apuntadores .................................................................................... p. 89

Autor: Francisco J. Arce A. página 178/180 [Link]

 Introducción a C++
7.1. Estructuras ................................................................................................................ p. 90
7.2. Poblar una estructura ................................................................................................ p. 91
7.3. Estructuras anidadas ................................................................................................ p. 92
7.4. Definir tipos con typedef ............................................................................................ p. 93
7.5. Arreglos de estructuras ............................................................................................. p. 94
7.6. Estructuras anónimas ............................................................................................... p. 95
7.7. Utilizar estructuras como parámetros ....................................................................... p. 96
7.8. Uniones ..................................................................................................................... p. 97
Capítulo 8: Apuntadores o punteros en lenguaje C++ ............................................................ p. 98
8.1. Introducción a los apuntadores ................................................................................. p. 99
8.2. Definición y asignación de un apuntador .................................................................. p. 100
8.3. Apuntadores especiales: NULL y void ...................................................................... p. 101
8.4. Apuntadores de apuntadores .................................................................................... p. 102
8.5. Apuntadores y Arreglos ............................................................................................. p. 103
8.6. Arreglos de Apuntadores .......................................................................................... p. 104
8.7. Apuntadores a cadenas ............................................................................................ p. 105
8.8. Apuntadores constantes ........................................................................................... p. 106
8.9. Apuntadores a estructuras ........................................................................................ p. 108
8.10. Aritmética de apuntadores ...................................................................................... p. 109
Capítulo 9: Espacios de nombres y clases: introducción a la programación orientada a obj . p. 110
9.1. Espacios de nombres ................................................................................................ p. 111
9.2. Definición de clases en C++ ..................................................................................... p. 113
9.3. Definir una clase ....................................................................................................... p. 114
9.4. Archivos de encabezados ......................................................................................... p. 115
9.5. Constructores ............................................................................................................ p. 116
9.6. Iniciación en constructores ........................................................................................ p. 118
9.7. Sobrecarga de constructores y otras características ................................................ p. 120
9.8. Destructores de instancias ........................................................................................ p. 122
9.9. El apuntador this ....................................................................................................... p. 123
Capítulo 10: Funciones amigas y modificadores .................................................................... p. 124
10.1. Funciones amigas ................................................................................................... p. 125
10.2. Funciones amigas en otras clases .......................................................................... p. 126
10.3. Clases amigas ......................................................................................................... p. 128
10.4. Getters y setters ...................................................................................................... p. 130
10.5. Funciones en línea .................................................................................................. p. 132
10.6. Valores de retorno constantes ................................................................................ p. 133
10.7. Valores de retorno constantes ................................................................................ p. 134
10.8. Sobrecarga de funciones miembro o métodos ....................................................... p. 135

Autor: Francisco J. Arce A. página 179/180 [Link]

 Introducción a C++
10.9. Sobrecarga de operadores ..................................................................................... p. 137
10.10. Sobrecarga de operadores unarios ....................................................................... p. 139
10.11. Operadores de conversión de tipos ...................................................................... p. 141
Capítulo 11: Herencia y polimorfismo ..................................................................................... p. 143
11.1. La herencia en el lenguaje C++ .............................................................................. p. 144
11.2. Constructores de las clases derivadas ................................................................... p. 146
11.3. Llamar a un método de otra clase ........................................................................... p. 148
11.4. Destructores de clases derivadas ........................................................................... p. 149
11.5. Sobre escribir u overriding un método .................................................................... p. 150
11.6. Overriding y la sobrecarga ...................................................................................... p. 152
11.7. Herencia múltiple .................................................................................................... p. 153
11.8. Los constructores en la herencia múltiple ............................................................... p. 154
11.9. Herencia virtual ....................................................................................................... p. 155
11.10. Enlaces o ligaduras ............................................................................................... p. 156
11.11. Funciones virtuales ............................................................................................... p. 158
11.12. Polimorfismo ......................................................................................................... p. 160
Capítulo 12: Funciones y clases con plantillas o templates .................................................... p. 162
12.1. Plantillas o templates .............................................................................................. p. 163
12.2. Tipos de datos en las plantillas ............................................................................... p. 164
12.3. Plantillas en archivo de encabezados ..................................................................... p. 165
12.4. Plantillas y arreglos ................................................................................................. p. 166
12.5. Plantillas de clases .................................................................................................. p. 168
12.6. Plantillas en archivos de encabezado ..................................................................... p. 169
12.7. Crear una clase Pila ................................................................................................ p. 171
12.8. Clases plantilla con clases ...................................................................................... p. 174
Indice ...................................................................................................................................... p. 177

Autor: Francisco J. Arce A. página 180/180 [Link]

Powered by TCPDF ([Link])