PDF de programación - Curso de introducción a C++ para programadores en C

Curso de Introducción a C++

Para Programadores en C



Luis de Salvador

Luis de Salvador

1



INDICE


INTRODUCCIÓN A LAS CLASES ........................................................................................... 4

1.

2. PUNTEROS A FUNCIONES ...................................................................................................... 6

3. DECLARACIÓN DE FUNCIONES EN UNA CLASE............................................................... 7

4. OTRAS CARACTERÍSTICAS DE LAS FUNCIONES EN C++............................................... 9
SOBRECARGA ............................................................................................................................. 9
4.1
OPERADORES.............................................................................................................................. 9
4.2
4.3
FUNCIONES INLINE ................................................................................................................... 10
CONSTRUCTORES...................................................................................................................... 10
4.4
FUNCIONES CON UN NÚMERO VARIABLE DE ARGUMENTOS........................................................... 10
4.5
FUNCIONES CON UN NÚMERO INDEFINIDO DE ARGUMENTOS ........................................................ 11
4.6
5.
INTRODUCCIÓN A LA HERENCIA...................................................................................... 12

6. ENTRADA/SALIDA EN C++ ................................................................................................... 13
6.1
SALIDA .................................................................................................................................... 13
6.2
ENTRADA................................................................................................................................. 14
7. PASO POR REFERENCIA....................................................................................................... 16

8. TIPOS CALIFICADOS COMO CONSTANTES..................................................................... 16

9. FUNCIONES VIRTUALES ...................................................................................................... 17

10.

11.

TEMPLATES ........................................................................................................................ 19

EL PUNTERO THIS............................................................................................................. 20

12. MANEJO DE EXCEPCIONES ............................................................................................ 22
12.1
FUNCIÓN TERMINATE................................................................................................................ 23
12.2 ESPECIFICACIÓN DE EXCEPCIONES............................................................................................. 23
12.3 MANEJADOR DE ERRORES CON NEW .......................................................................................... 23
FUNCIONES DESTRUCTORAS ......................................................................................... 25
13.

14.

15.

16.

17.

18.

HERENCIA MÚLTIPLE...................................................................................................... 25

COMPOSICIÓN DE CLASES.............................................................................................. 27

FUNCIONES COMO PARTE DE UNA ESTRUCTURA.................................................... 27

DIFERENCIAS ENTRE PUBLIC, PRIVATE Y PROTECTED......................................... 28

CAMPOS DE BIT ................................................................................................................. 28

19.
19.1
19.2

DIFERENCIAS ENTRE COMPILAR UN PROGRAMA EN C COMO C++.................... 29
FUNCIÓN SIZEOF ....................................................................................................................... 29
PROTOTIPOS............................................................................................................................. 29

Luis de Salvador

2

SOLUCIONES A LOS EJERCICIOS .................................................................................. 31
20.
20.1 EJERCICIO 1: ............................................................................................................................ 31
20.2 EJERCICIO 2: ............................................................................................................................ 32
20.3 EJERCICIO 3: ............................................................................................................................ 33
20.4 EJERCICIO 4: ............................................................................................................................ 34
20.5 EJERCICIO 6 ............................................................................................................................. 39
20.6 EJERCICIO 7 ............................................................................................................................. 41
20.7 EJERCICIO 8 ............................................................................................................................. 43
20.8 EJERCICIO 9 ............................................................................................................................. 45
20.9 EJERCICIO 10............................................................................................................................ 47
20.10
EJERCICIO 11 ....................................................................................................................... 50



Luis de Salvador

3



1. Introducción a las Clases

Una clase es un tipo definido por el usuario, como las estructuras y uniones. La
definición de clase se emplea para especificar un conjunto de datos que forman parte de
la clase así como el conjunto de operaciones que se pueden emplear sobre los objetos de
dicha clase.

Una clase se define básicamente de la siguiente forma:



<parte privada>

class nombre_de_la_clase {

public:

};

<parte pública>



En la parte privada se definen los datos (atributos) y las funciones (métodos) que son
accesibles unicamente por funciones que sean miembros o friend (amigas) de las clase.
Las funciones miembro son aquellas funciones que se encuentran definidas en el ambito
de la clase y no fuera de ese ambito (ambito de la clase, que es diferente del ambito de
declaración de la clase).

Por defecto, todas las definiciones realizadas antes de la palabra public son privadas.
Se puede incluir la palabra private para declarar una parte privada. Se pueden incluir
tantas partes privadas como públicas que se deseen.

En la parte publica se definen los datos y las funciones que son accesibles fuera del

ambito de la declaración de la clase.

Ejemplo de definición de una clase

/* Constructor de la clase */
string() {str = new char[10];



*str = 'a';
*(str+1) = NULL; }

/* objeto privado de la clase */
char *str;

#include "stdio.h"

class string {


public:



/* Función miembro de clase */



};

void main () {
string s;

if (!null_test(s)) /* manipulación de la clase */


return;
}

void print() { printf("%s\n", str); }
/* Función amiga de la clase */
friend int null_test ( string s){

}

/* inicialización del objeto*/

return (*s.str == NULL);

s.print();



Luis de Salvador

4

Notas sobre el ejemplo:
?? La parte privada de la clase es un puntero a una cadena de caracteres Por lo
tanto, esta cadena de caracteres solo podrá ser accedida desde funciones que
sean miembro o amigas de la clase.

?? Las funciones miembro de una clase no necesitan referenciar a los objetos

privados de la clase via clase.miembro.

?? Las funciones miembro de una clase se invocan a partir de un objeto de la clase
( s.print()). Este “.” se denomina operador de acceso a un miembro de la clase.
?? Una de las funciones definidas en la parte pública ha de ser una función
constructora. Esta función es la empleada para realizar las declaracion de una
variable como de tipo la clase considerada y, a su vez, inicializarla. En esta
función se prevee la devolución de ningún tipo.

?? La función para reservar espacio en memoria es new, la función para liberarlo es

delete.

Es posible que un miembro de la clase sea del mismo tipo que la clase. De igual
forma que ocurría en la declaración de estructuras, este miembro ha de ser puntero al
tipo de la clase.

Una clase puede ser declarada y no definida, para ser definida posteriormente. La

declaración de una clase sin cuerpo tiene la forma:

class nombre_de_clase;

Ejercicio 1: Crear un objeto llamado nodo que se el núcleo de un arbol binario. Por
lo tanto, que sea capaz de almacenar dos punteros a dos nodos. Cada nodo puede
almacenar los siguientas datos de forma excluyente: o bien un valor double o bien otro
puntero a otro nodo del mismo arbol.

Escribir una función constructura y las siguientes funciones amigas:
void crear (nodo *, int )

Crea un nuevo nodo a la izquierda o a la derecha del nodo actual en función

de un parámetro en int.

void cambiar_v (nodo *el_nodo, double *valor)

Añadir al nodo actual el valor especificado.

void cambiar_n (nodo *el_nodo, nodo *nuevo)
Añadir al nodo actual un nuevo puntero.

nodo* viajar (nodo *el_nodo, int valor)

Devuelve el nodo izquierdo o derecho en función del valor entero.

Escribir una función main que compruebe el correcto funcionamiento de las

funciones.

Luis de Salvador

5

2. Punteros