PDF de programación - Introducción a C++

Introducción a C++, por Nacho Cabanes



Introducción a C++



Este texto pretende ser una introducción a la programación orientada a objetos y al lenguaje
C++, para gente que ya conozca el lenguaje C.

Este texto ha sido escrito por Nacho Cabanes. Si quiere conseguir la última versión, estará en
mi página web:


www.nachocabanes.com



Este texto es de libre distribución (“gratis”). Se puede distribuir a otras personas libremente,
siempre y cuando no se modifique.

Este texto se distribuye "tal cual", sin garantía de ningún tipo, implícita ni explícita. Aun así, mi
intención es que resulte útil, así que le rogaría que me comunique cualquier error que
encuentre.

Para cualquier sugerencia, no dude en contactar conmigo a través de mi web.



Revisión actual: 0.04

Revisión 0.04 – Página 1

Introducción a C++, por Nacho Cabanes

Contenido
(Revisión actual: 0.04)
1. ¿Qué es la programación orientada a objetos? ___________________________________________5
2. Creando un objeto con C++ __________________________________________________________6
3. Constructores y destructores _________________________________________________________9
4. Separando la interfaz y la implementación. ____________________________________________12
5. Extensiones de los ficheros _________________________________________________________15
6. Especificadores de acceso __________________________________________________________16
7. Heredando y ampliando la clase base._________________________________________________16
8. Redefiniendo la clase base para otro sistema ___________________________________________19
9. Una clase que use la anterior. _______________________________________________________22
10. Otras diferencias entre C y C++_____________________________________________________26
11. Más sobre entrada y salida en C++ __________________________________________________29
12. Ficheros en C++. ________________________________________________________________32



Revisión 0.04 – Página 2

Introducción a C++, por Nacho Cabanes


(Página dejada en blanco intencionadamente para cuando el índice sea más completo)


Revisión 0.04 – Página 3

Introducción a C++, por Nacho Cabanes



Revisiones de este texto hasta la fecha:


0.04, de 12-Jul-06. Ampliado hasta 13 apartados, 37 páginas.
0.03, de 28-Abr-06. Ampliado hasta 10 apartados, 28 páginas.
0.02, de 27-Abr-06. Incluye 7 apartados, 19 páginas.
0.01, de 26-Abr-06. Primera versión disponible, con 3 apartados, 12 páginas.



Revisión 0.04 – Página 4

Introducción a C++, por Nacho Cabanes



1. ¿Qué es la programación orientada a objetos?

El lenguaje C++ es un lenguaje creado con la base del lenguaje C, pero ampliado para permitir
Programación Orientada a Objetos (también hay alguna otra diferencia, que ya iremos viendo).
Por eso, vamos a empezar viendo las generalidades de la Programación Orientada a Objetos y
después iremos particularizando para el caso de C++...

Hasta ahora estamos estado “cuadriculando” todo para obtener algoritmos: tratábamos de
convertir cualquier cosa en funciones y variables que pudieramos emplear en nuestros
programas.


Pero no todo lo que nos rodea es tan fácil de cuadricular. Supongamos por ejemplo que
tenemos que describir una puerta desde nuestro programa. En la zona de declaración de
variables detallaríamos datos como su tamaño o su color. Pero no basta con eso. De hecho, eso
no es lo más importante: lo que hace que una puerta sea una puerta es el hecho de que se
pueda abrir y se pueda cerrar. Por tanto, si queremos simular o controlar una puerta desde
nuestro programa, deberíamos crear también las funciones AbrirPuerta y CerrarPuerta en
alguna otra parte de nuestro fuente.

No está mal, pero es antinatural: una puerta es un conjunto: no podemos separar su color de
su tamaño, o de la forma en que debemos abrirla o cerrarla. Sus características son tanto las
físicas (lo que hasta ahora llamábamos variables) como sus comportamientos en distintas
circunstancias (lo que para nosotros eran las funciones). Todo ello va siempre unido, formando
un OBJETO.

Por otra parte, si tenemos que explicar a alguien lo que es el portón de un garaje, y ese alguien
no lo ha visto nunca, pero conoce cómo es la puerta de su casa, le podemos decir “se parece a
una puerta de una casa, pero es más grande para que quepan los coches, está hecha de metal
en vez de madera...”. Las dos cosas son puertas: se trata de dos objetos que pertenecen a la
misma CLASE.

Finalmente, conviene recordar que “abrir” no se refiere sólo a una puerta. También podemos
hablar de abrir una ventana o un libro, por ejemplo.

Pues con esta discusión hemos comentado casi sin saberlo las tres características más
importantes de la Programación Orientada a Objetos (OOP):


• ENCAPSULACION: No podemos separar los comportamientos de las características de
un objeto. Los comportamientos del objeto serán funciones, que en OOP llamaremos
MÉTODOS. Las características del objeto serán variables, como las que hemos usado
siempre, que en OOP llamaremos ATRIBUTOS. La apariencia de un objeto en C++,
como veremos un poco más adelante, recordará a un registro o “struct”, que contendrá
funciones además de datos.



Revisión 0.04 – Página 5

Introducción a C++, por Nacho Cabanes

• HERENCIA: Unos objetos pueden “heredar” métodos y atributos de otros. Esto hace
más fácil definir objetos nuevos a partir de otros que ya teníamos anteriormente (como
ocurría con el portón y la puerta) y facilitará la reutilización de los programas, pudiendo
aprovechar buena parte de los anteriores... si están bien diseñados.


• POLIMORFISMO: Un mismo nombre de un método puede hacer referencia a
comportamientos relativamente distintos (como abrir una puerta o abrir un libro). En
C++ el polimorfismo llega incluso al nivel de los operadores: podremos “redefinir” el
operador + para que sume matrices, ficheros o cualquier tipo de objeto que nos
interese1.



(Nota: en C++ es frecuente llamar también "variables de instancia" o "variables
miembro" a los atributos, y "funciones miembro" a los métodos).



Comentado esto, vamos a empezar a ver ejemplos en C++ para tratar de fijar estos primeros
conceptos y de ver la sintaxis de este lenguaje. A partir de unos primeros ejemplos sencillos,
iremos profundizando paulatinamente.



2. Creando un objeto con C++
Vamos a empezar por hacer algo frecuente: crear un objeto "pantalla", que nos aisle totalmente
del hardware, del sistema operativo y del compilador que estemos utilizando. Así, luego
podremos definir un objeto "ventana" (por ejemplo), que muestre la información accediendo al
objeto "pantalla".

Si después queremos que nuestro programa funcione en otro entorno distinto, bastará con
crear una nueva versión del objeto "pantalla", que internamente trabaje de forma distinta, pero
externamente responda a los mismos mensajes que el objeto "pantalla" inicial.

Así, todo el resto del programa funcionará en el nuevo entorno sin ningún cambio adicional.

En nuestro caso, nos centraremos en un objeto que nos oculte el acceso directo a la pantalla, y
que estará particularizado (inicialmente) para el compilador Turbo C++, bajo MsDos. Después
del fuente están los comentarios sobre él.


1 Realmente, este tipo de polimorfismo recibe el nombre de “sobrecarga de operadores”, como ya
veremos.

Revisión 0.04 – Página 6



Introducción a C++, por Nacho Cabanes

//
// pant01.cpp
//
// Introducción a C++
// Por Jose Ignacio Cabanes
// Primer ejemplo (en un sólo fuente)
// Versión para TC++ (MsDos)
// Probado con Borland C++ 5.5 FCLT
//
/////////////////////////////////////////////

#include <conio.h>

// ---------------------------------------------------------
// CLASE : PantallaTexto
// Oculta el funcionamiento de la pantalla en modo texto.

class PantallaTexto {
char maxX, minX; // Coordenadas máxima y mínima (horizontal)
char maxY, minY; // Coordenadas máxima y mínima (vertical)

public:
void Borra(); // Borra toda la pantalla
void Escribe(int X,
int Y, char *texto); // Escribe un mensaje en ciertas coordenadas
int LeeTecla(); // Espera una tecla y la devuelve
int LeerMaxX(); // Devuelve coordenada X máxima
};

// ========================================================================
// A continuación viene el desarrollo de las funciones (métodos)

// ----------------- PantallaTexto - Borra -----------------
// Borra toda la pantalla

void
PantallaTexto::Borra() {
clrscr();
}

// ----------------- PantallaTexto - Escribe ---------------
// Escribe un mensaje en ciertas coordenadas

void
PantallaTexto::Escribe(int X, int Y, char *texto) {
gotoxy(X, Y);
cputs(texto);
}


// ----------------- PantallaTexto - LeeTecla --------------
// Espera una tecla y la devuelve

int
PantallaTexto::LeeTecla() {
return getch();
}


// ----------------- PantallaTexto - LeerMax ---------------
// Devuelve la coordenada horizontal máxima

int
PantallaTexto::LeerMaxX() {
return maxX;
}


// ========================================================================
// Finalmente: un programa sencillo de ejemplo

main() {
PantallaTexto pant; // Definimos un objeto de la clase "PantallaTexto"

pant.Borra();

Revisión 0.04 – Página 7

Introducción a C++, por Nacho Cabanes

pant.Escribe(30,14, "Hol