Aprendiendo objetos en C++

APRENDIENDO OBJETOS EN C++

Abstracción de Datos
Consiste en la extracción de las propiedades fundamentales de un concepto. Permite no preocuparse por los detalles no esenciales, es decir, no es necesario conocer los detalles exactos de la implementación. Existe casi en todos los lenguajes de programación. Las estructuras de datos y los tipos de datos son un ejemplo de abstracción.

Programación Orientada a Objetos
La programación orientada a objetos (POO) es una técnica o estilo de programación que utiliza objetos como bloque esencial de construcción.

Programas Orientados a Objetos
Un programa orientado a objetos es una colección de clases. Necesita de una función principal que cree objetos y comience la ejecución mediante la invocación de sus funciones o métodos.
En primer lugar, se crean los objetos. Segundo, los mensajes se envían desde unos objetos y se reciben en otros a medida que el programa se ejecuta. Y tercero, se borran los objetos cuando ya no son necesarios y se recupera la memoria ocupada por ellos.
Los objetos son tipos de datos abstractos definidos por el programador. En realidad son unidades que contienen datos y funciones que operan sobre esos datos. A los objetos también se les conoce como instancias de clase.
A los elementos de un objeto se les conoce como miembros (datos miembros y funciones miembro).

Ejemplos de objetos
ventanas, iconos, arreglos, pilas, colas, árboles binarios, números complejos.
Los datos de un objetos están ocultos y solamente a través de sus funciones pueden ser accesados.
Todos los campos miembros y funciones están completamente en el interior del objeto y son ocultos desde el exterior, lo que significa que están encapsulados.
A las funciones de un objeto también se les conoce como métodos y a los datos como variables.

Clase
Es un modelo que se utiliza para describir uno o más objetos del mismo tipo.
La comunicación con un objeto se realiza a través del paso de mensajes. El envío de un mensaje a una instancia de una clase produce la ejecución de un método (función miembro en C++).

Herencia
Es la propiedad que permite a los objetos construirse a partir de otros objetos. Este principio consiste en que cada clase puede dividirse en subclases, es decir, a partir de una clase base se pueden derivar otras clases (clases derivadas) que comparten características comunes con la clase de la que se derivan, además de tener sus propias características particulares.
La Herencia permite definir nuevas clase a partir de clases ya existentes.
Si una clase sólo recibe características de una clase base, la herencia es simple.
Si una clase recibe propiedades de más de una clase base, la herencia es múltiple.

Clase Base

Característica A
Característica B

|
V

Característica A
Característica B
Característica C
Característica D
Característica E

Característica A
Característica B
Característica C

Clases Derivadas

Polimorfismo
En la POO el polimorfismo se refiere al hecho de que una misma operación puede tener diferente comportamiento en diferentes objetos. En otras palabras, diferentes objetos reaccionan al mismo mensaje de manera diferente.
Por ejemplo, supongamos un número de figuras geométricas que responden todas al mensaje Dibujar. Cada objeto reacciona a este mensaje visualizando su figura en la pantalla. Obviamente, el mecanismo real para dibujar los objetos difiere de una figura a otra, pero todas las figuras realizan esta tarea en respuesta al mismo mensaje.

Reutilización
Una vez que una clase se ha escrito creado, depurado y utilizado, se puede difundir entre otros programadores para que pueden reutilizarla en sus programas. Un programador puede tomar la clase existente, y sin modificarla añadir características adicionales a la misma. Estas operaciones se realizan por derivación de una clase nueva a partir de una clase ya existente.
La reutilización del software es un término muy importante, que Brad J. Cox ha definido con el concepto de Chip de Software (IC-Software), queriendo significar que esta propiedad es similar a la utilización del hardware mediante circuitos integrados.

Clases en C++

Concepto de Clase
Una clase es un tipo de dato que contiene uno o más elementos datos llamados miembros dato, y cero, una o más funciones que manipulan esos datos llamados funciones miembro o métodos. Una clase se puede definir como una estructura (struct), una unión (union) o una clase (clase). La sintaxis de la clase es la siguiente:

class nombre_clase {
miembro_1;
miembro_2;
miembro_3;
...
función_miembro_1( argumentos);
función membro_2 (argumentos);
función_miembro_3(argumentos);
...};

Dada una clase, pueden definirse uno o más objetos o instancias de la misma, los cuales tendrán los datos y métodos definidos para dicha clase.

nombre_clase objeto_1;
nombre_clase objeto_2;
Sin embargo, también pueden declararse apuntadores a una clase. Un apuntador o referencia a una clase proporciona medios indirectos para acceder a un objeto, pero no es una instancia de clase.
Así, un objeto es una instancia de clase y de modo similar una variable es una instancia de un tipo predefinido.
Una clase es un tipo de estructura que encasilla datos y funciones en una entidad:

Componentes de una clase
Una definición de una clase consta de dos partes: una declaración y una definición. La declaración lista los miembros de la clase. La implementación o cuerpo define las funciones de la clase.

int angf;
int radio;
public:
rebanada(int X, int Y, Int angi, int ang f, int radio);
Rellena(int patron, int color);
Dibuja();
};

Así, si declaramos lo siguiente:

void main(void)
{
rebanada Rebanada1(10, 10, 0, 90, 50);
rebanada Rebanada2(10,10, 90, 180,50);
rebanada*ap_Rebanada;
}

Tanto Rebanada1 como Rebanada2 son objetos de la clase rebanada, mientras que ap_rebanada es sólo un apuntador a instancias de esa clase.

Control de acceso a una clase
Una de las características fundamentales de una clase es ocultar tanta información como sea posible. Por consiguiente es necesario imponer ciertas restricciones de acceso a los datos y funciones de una clase.
Una clase puede contener partes públicas y partes privadas. Por defecto, todos los miembros definidos en una clase son privados, aunque se puede especificar la palabra reservada private. Si se desea hacer algunas o todas la partes de una clase públicas, es necesario definirlas después de la palabra reservada public.
Todas los datos o funciones definidos como públicos pueden ser accesados solamente por funciones de la propia clase. No así aquellas que se definen como publicas, que pueden ser accesadas desde cualquier función del programa.
Dada que una característica clave en la Programación Orientada a Objetos es el ocultamiento de información, se debe tratar de eliminar o limitar al máximo tener variables públicas. Las funciones de una clase, sin embargo, generalmente se hacen privadas para poder manipular al objeto desde el lugar del programa que el programador desee. Ver ejemplo clase rebanada.

¿Quiénes pueden usar las clases?
Existen tres clases de usuarios de una clase: la propia clase, usuarios genéricos y las clases derivadas. Cada uno de ellos tiene diferentes privilegios de acceso que se asocia con las palabras reservadas:

1.- private ------------- La propia clase
2.- public -------------- Usuarios genéricos
3.- protected ---------- Clases derivadas.

Declaración de variables y funciones miembro de una clase

class A {
int x;
float y;
public:
int z;
void f();
};
void main(void)
{
A vardemo;
}

vardemo es un objeto de tipo <> que se compone de tres campos de datos (x, y, z) y de una función de acceso (f). Los campos x,y sólo podrian ser modificadas a través de la función f, para lo cual se escribirá: vardemo.f();
Esto en términos de programación orientada a objetos se leería: se envía el mensaje f() al objeto vardemo. En otras palabras: se ejecuta la función f aplicada al objeto vardemo.
La definición de las funciones miembre es muy similar a la definición ordinaria, ya conocida, de función. Tienen un encabezado y un cuerpo y pueden tener tipos y argumentos. sin embargo tienen dos características muy especiales:

Cuando se define una función miembro, se utiliza el operador de resolución de ámbito :: para identificar la clase a la que pertenece la función.
Las funciones miembro (métodos) de las clase pueden acceder a los componentes privados de la clase.

class CLS {
int x;
int y;
public:
void f() { cout << "\nX=" << x << " Y=" << y; }
};
class CLS {
int x;
int y;
public:
void f();
}
void CLS::f()
{
cout << "\nX=" << x << " Y=" << y;
}

En el primer caso la función está en línea (inline). Por cada llamada a esta función, el compilador genera (vuelve a copiar) las diferentes instrucciones de la función. En el segundo caso la función se llamará con una llamada verdadera a función.

Las clases con estructuras
Una estructura (struct) en C++ es también una clase en la que todos sus miembros son por defecto públicos, a menos que sean modificados por las palabras reservadas private o protected.

struct alfa {
private:
int x, y;
public:
//resto de la estructura, prototipos de funciones
}

Objetos
En C++, un objeto es un elemento declarado de un tipo de clase. Se conoce como una instancia de una clase.

class rectangulo {
int base, altura;
public:
void dimensiones (int b, int h) { base=b; altura=h; }
int area(void) { return base * altura; }
};
main ()
{

rectangulo MiRectangulo; //Se declara el objeto
MiRectangulo.dimensiones(10, 5); //Se define el tamaño del objeto
cout << "Area= " << MiRectangulo.area(); //Se calcula el área del objeto y se imprime
rectangulo * ap_TuRectangulo = new rectangulo; //Se declara apuntador al obj.
ap_TuRectangulo->dimensiones(10, 20); //Se define el tamaño del objeto
cout << "Area= " << ap_TuRectangulo->area(); //Se calcula el área del obj. se imprime
}

Puede observarse en el ejemplo anterior que los miembros a una clase se accesan por medio del operador punto (.) si se trata de una variable de una variable (objeto) del tipo de la clase y por el operador flecha (->) si se trata de un apuntador un objeto de la clase.

Clases vacías class vacia {};
con frecuencia en el desarrollo de proyectos grandes, se necesitan comprobar implementaciones de primeras versiones en las que algunas clases todavía no están totalmente definidas o implementadas.

Clases anidadas
Una clase declarada en el interior de otra clase se denomina clase anidada, y se puede considerar como una clase miembro. Si una clase anidada es declarada en la sección private de la clase circúndate, será solo utilizable por miembros de datos de la clase que la circunde. Si un nombre de una clase anidada es accesible a una clase o función que no la circunda, se debe aplicar el operador de resolución de ámbito (::) para utilizar su nombre.

class Externa {
public:
class Interna {
public:
int x;
};
};
void main(void)
{
Externa::Interna valor;
int v = valor.x;
}
class clase_2 {
public:
int i;
};
class clase_1{
public:
int j;
clase_2 variable_2; //variable_2 es una clase anidada
};
void main(void)
{
clase_1 variable_1;
variable_1.variable_2.i=125;
}

Miembros estáticos de una clase
Para un miembro dato, la designación static significa que sólo existe una instancia de ese miembro. Es compartido por todos los objetos de una misma clase y existe incluso si ningún objeto de esa clase existe. Se le asigna una zona fija de almacenamiento.

class Ejemplo {
static int varest; //se declara miembro estático privado
public:
static int valor; //se declara miembro estático público
};
int Ejemplo:: valor; //se define miembrosestático
int Ejemplo::varest;
void main(void)
{ Ejemplo objeto1;
objeto1.valor=1;
objeto1.valor=3;
Ejemplo::valor=3; //se puede referenciar usando el identificador de clase. Es la manera ideal de hacerlo
Ejemplo::valres=5; //Acceso válido
objeto1.valres=6; // Acceso no válido
}

Tipos de funciones miembro
1.- Simples
2.- Estáticas
3.- const
4.-volatile
5.- inline
6.- const this
7.- volatile this
8.- Virtuales
9.- Especiales: constructor y destructor
10.- Amigas
11.- opeator

El apuntador this
Dentro de una función miembro, this apunta al objeto asociado con la invocación de la función miembro. A través de este apuntador, una función puede saber qué objeto la está llamando.

complejo::complejo(float 1, float b)
{
this->r=a;
this->i=a;
}

Aunque su uso se considera redundante e innecesario, puede ser útil en ciertas situaciones, como por ejemplo para hacer una copia del objeto asociado con la invocación o asignar un nuevo valor al objeto.

void clase_x :: funcion_x(clase_x& a, clase_x &b)
{ ...
a=this; //Asigna el valor del objeto asociado al objeto a
...
this=b; //Modifica el valor del objeto asociado
}

Acceso al objeto mediante this
this -> nombre_miembro
*this es el objeto total real
this es la dirección del objeto apuntado.

Funciones miembro estáticas
Sólo pueden accesar a otras funciones y datos estáticos declarados en una clase, pero no pueden manipular funciones ni datos no estáticos, debido a que no tienen asignado un apuntador this, a menos que se pase explícitamente este apuntador this.

int v1, v2, v3; //Al ser globales son estáticas
class Prueba{
public:
static void suma():
};
void Prueba::suma() { v1=v2+v3; }
void main(void)
{ Prueba p1; p1.suma(); Prueba::suma(); }

Funciones miembro const
Devuelven objetos del tipo const.

class FunConst{
public:
const int f() { return 5; }
}
void main()
{ FunConst s; cons int i=s.f(); int y=s.f(); }

Funciones miembro en línea (inline)
Al igual que cualquier otra función de C++, las funciones miembro pueden ser funciones en línea. Existen dos medios para hacer funciones miembro en línea: aplicando la palabra reservada inline a la definición o definiendo la función dentro de la declaración de la clase.

class clase_xy {
int x,y;
public:
void Despliega_x (void) { cout << "X= " << x; } //Función miebro en línea
void Despliega_y(void);
};
inline void clase_xy::Despliega_y(void) //Función miebro en línea
{
cout << "Y= " << y;
}

Constructores
En C++ la inicialización de objetos no se puede realizar en el momento en que son declarados. Para ello se dispone de los constructores. Un constructor es una función que sirve para construir un nuevo objeto y/o inicializarlo, asignando valores a sus miembros dato.

Características de los constructores:
- Tiene el mismo nombre que la clase que inicializa.
- Puede definirse inline o fuera de la clase que inicializa.
- No devuelven valores
- Puede admitir parámetros como cualquier otra función.
- Pueden existir cero, uno o más constructores para una misma clase.

class rebanada {
int x_centro, y_centro, angulo_i, angulo_f, radio;
public:
rebanada(int x, int y, int ai, int af, int r) } //Constructor
x_centro=x; y=centro=y; angulo_i= ai; angulo_f=af; radio=r;
}
...// Otros métodos
}

Los constructores pueden implicar diferentes escenarios: Crear objetos por inicialización por defecto, crear objetos con inicialización específica, crear objetos por copia de otro objeto.
Los constructores no se pueden declarar static o virtual. Se declaran normalmente en la sección pública, pero pueden declararse en cualquier parte de una clase. Si no se declara específicamente un constructor, C++ inserta automática e invisiblemente un constructor por defecto que no acepta argumentos. Este constructor por defecto asigna espacio de almacenamiento para construir un objeto de su clase y lo pone en ceros.

Constructores con argumentos
La mayoría de los constructores en C++ toman argumentos. La función básica de un constructor es inicializar un objeto antes de utilizarlo.
Se pueden declarar constructores múltiples, mientras tomen tipos o números de argumentos.

class complejo {
private:
double real,imag;
públic:
complejo() { real=0; imag=0 } //son constructores sobrecargados
complejo(double x) { real=x; imag=0; }
complejo( double x, double y ) { real=x; imag=y }
complejo(complejo& c) {real=c.real; imag=c.omag} //constructor copiador
}
void main(void)
{
complejo c1;
complejo c2(1.2);
complejo c3(1.2, 2.4);
complejo c4=c2; //llama al constructor copiador
}

Mecanismo alternativo de paso de argumentos
Consiste en inicializar miembros dato como parámetros. Los constructores de complejo quedarían:

complejo(double x=0, double y=0) : real(x), imag(y) { }
complejo(complejo& c): real(c.real), imag(c.imag) { }

Constructores sobrecargados
Un constructor puede tener el mismo nombre pero diferentes tipos de datos como argumentos. El constructor correcto es llamado por el compilador según sean los datos de sus argumentos. Ver ejemplo complejo.

Constructores copiadores
Es un cosntructor que crea un objeto a partir de uno ya existente. Tiene sólo un argumento: una referencia constante a un argumento de la misma clase.

class fibonacci {
public:
fibonacci() { var1=0; var2=1; resultado= var1+var2; } //constructor ordinario
fibonacci( const fibonacci &p ) { var1=p.var1; var2=p.var2; resultado=p.resultado; }
}

Paso de objetos por valor
Cuando se llama a una función que recibe a un objeto por valor, el compilador utiliza el constructor de copias de los objetos en la pila como un argumento. El paso por valor no significa que la función obtenga necesariamente una copia byte a byte de un objeto.

void lee_complejo( Cuenta objeto)
{
cout << "El objeto Cuenta es: " << objeto.LeerValor());
}
void main(void)
{
Contador objeto(10);
informe_cuenta(objeto);
}

Creación de objetos
Forma abreviada: Complejo c1, c2(10), c3(3.4); Complejo c4=c1;
Forma explícita: Complejo c1=complejo(); Complejo c2=complejo(10); Complejo c3=complejo(3.4);

Destructores
Un destructor es una función miembre con igual nombre que la clase, pero precedido por un caracter tilde ^ .Una clase sólo tiene una función destructor, no tiene argumentos y no devuelve ningún tipo. Al igual que las demás funciones miembro puede estar definido dentro o fuera de la clase.

class String {
private:
unsigned lon;
char sstr;
public:
String(const char s) { strcpy(sstr, s); } //constructor
^String() { delete[] sstr; } //destructor
// Otros miembros
}

Los destructores pueden ser públicos o privados, según si se declaran en la parte private o public de la clase. Si es público se puede llamar desde cualquier parte del programa para destruir el objeto. Si es privado no se permite la destrucción del objeto por el usuario.

Creación y supresión dinámica de objetos
Los operadores new y delete se pueden usar para crear y destruir objetos de una clase, así como dentro de funciones constructoreas y destructoras.
la expresión new devuelve un apuntador a la dirección base del objeto.

p=new int(9);
Cadena *Cad2 = new Cadena;

Un objeto creado con new se destruye explícitamente mediante el operador delete. Si new falla al asignar almacenamiento, devuelve el valor 0.

class cadena {
char *datos;
public:
cadena (int lon) { datos= new char [lon]; } //constructor
^cadena(void) { delete datos}; } //destructor
}

Argumentos por defecto (omisión)
En C++, se pueden especificar los valores por defecto cuando se proporciona un prototipo de una función. Estos argumentos por defecto son proporcionados al compialdor si no se da ningún tipo de argumento a la llamada a la función. Si se pasa un valor a uno de los argumentos, se utiliza ese valor, si no se utiliza el valor por defecto como argumento. Deben cumplirse las siguientes reglas:
- Los argumentos por defecto se pasan por valor, no por referencia.
- Los valores por defecto pueden ser valores literales o declaraciones const. No pueden ser variables.
- Todos los argumentos por defecto deben estar situados al final del prototipo de la función. Después del primer argumento, todos los demás argumentos deben incluir valores por defecto.

void Visualizar (int n, int base = 10 ) { cout << n << "," << base; }
v
void Visualizar (int n, int base = 10 ) { cout << n << "," << base; }
void f()
{
Visualizar(47);
Visualizar(47,10);
Visualizar(50, 16);
}

Otro ejemplo:

void funcion(int i, int j=2, k=3, h=4);
void main()
{
funcion (1);
funcion (0, 1);
}
void funcion(int i, int j, int k, int h) { cout << i << "," << j << "," << k << "," << l; }

Funciones y clases amigas
Una función amiga es una función no miembro de una clase que puede tener acceso a los miembros privados de dicha clase. Estas funciones se declaran situando su prototipo de función dentro de la clase y mediante la palabra reservada friend. Asi, en la propia clase se determina qué funciones son amigas de ella.

class Cosa {
friend void cargar_dato( Cosa &, int); // función amiga
private:
int dato;
public:
Cosa (int d) { dato=d ; }
void prinf() { cout << "Dato = " << dato; }
}
void cargar_dato (Cosa & t, int d) { t.dato=x; }
void carga_otro_dato(Cosa &, int );
void main(void)
{
Cosa objeto1(0);
Cosa *ap_objeto;
ap_objeto = new cosa (1);
cargar_dato(objeto1, 2);
objeto1.print();
ap_objeto->print();
cargar_otro_dato(objeto1, 3);
}
void caga_otro_dato(Cosa & c, int y)
{
c.dato = y; // ERROR. NO ES FUNCION AMIGA
}

Además de las funciones amigas, se pueden tener clases completas como amigas de otra clase. En este caso, todas las funciones de la clase declarada como amiga pueden accesar las partes privadas de la otra clase. También se utiliza la palabra friend para declarar una clase como amiga de otra. Obviamente, la clase amiga debe estar declarada.

class nodo_bin {
friend arbol_bin ;
int inf;
nodo_bin hizq, hder, padre;
public:
nodo_bin(T dato) { inf=dato; hizq=hder=padre=NULL; bal=0; }
nodo_bin Leer_hizq() { return hizq; }
nodo_bin Leer_hder() { return hder; }
}
class arbol_bin {
nodo_bin raiz;
public:
arbol_bin() { raiz=NULL; };
nodo_bin Raiz() {return raiz; }
T info(nodo_bin nodo) { return nodo->Leer_inf(); }
// nodo_bin Left(nodo_bin nodo) { return nodo->Leer_hizq(); }
nodo_bin Left(nodo_bin nodo) { return nodo->hizq; }
//nodo_bin Right(nodo_bin nodo) { return nodo->Leer_hder(); }
nodo_bin Right(nodo_bin *nodo) { return nodo->hder; }
};

Sobrecarga de Funciones
El término sobrecarga se refiere al uso de un mismo nombre para múltiples significados de un operador o función. En C++ es posible dar el mismo nombre a varias funciones, la desición de ejecutar una u otra la realiza el compilador de acuerdo al tipo y/o número de argumentos. Los prototipos de estas funciones especifican sus tipos de retorno y argumentos para cada función en particular.

#include
int cuadrado (int i) { return ii; }
float cuadrado (float d) { return dd; }
long cuadrado (long l) { return l*l; }
void main(void)
{ int x;
long y;
float z;
x = cuadrado(5);
y = cuadrado(50000);
z = cuadrado(3.1416);
}

Las funciones sobrecargadas pueden ser miembros de alguna clase o no.
Si una función sobrecargada no es momiembro de alghuna clase, su ámbito es todo el programa.

#include
void Visualizar(char *string) { cout << string ; }
void Visualizar(long valor) { cout << valor ; }
void Visualizar(double valor) { cout << valot ; }
void main(void)
{ Visualizar("\n Este es un \"string\" ");
Visualizar(1234567890);
Visualizar(3.141592);
}

Funciones miembro sobrecargadas
El principal uso de la sobrecarga es con las funciones miembro de una clase. Cuando más de una función miembro con igual nombre se declara en una clase, se dice que el nombre de la función está sobrecargado en esa clase. El ámbito del nombre sobrecargado es el de la clase.
Es importante recordar que, los constructores, como funciones miembros de una clase, son suceptibles de sobrecargarse.

class figura {
char tipo;
float Area;
int color;
public:
char LeeAtributo() { return tipo; }
float LeeAtributo() { return Area; }
int LeeAtributo () { return color; }
void PonAtributo(int c) { color = c ; }
void PonAtributo(float A, int c) { Area= A; color=c ; }
}

Funciones amigas sobrecargadas
La sobrecarga de funciones amigas es similar a la de funciones miembreo con la diferencia de que es necesaria la palabra reservada friend al igual que en la declaración de cualquier función amiga.

class figura {
char tipo;
float Area;
int color;
public:
char LeeAtributo() { return tipo; }
float LeeAtributo() { return Area; }
int LeeAtributo () { return color; }
friend PonAtributo(int);
friend PonAtributo(float, int );
};
void PonAtributo(int c) { color = c ; }
void PonAtributo(float A, int c) { Area= A; color=c ; }

Las funciones sobrecargadas necesitan diferir por lo menos en uno de los siguientes puntos:
- Deben recibir un número diferente de argumentos.
- Al menos uno de los argumentos debe ser diferente en cuanto a su tipo.
La única función meimbre que no se puede sobrecargar es el destructor, debido a las reglas con que éstos se forman.
La sobrecarga de funciones evita la difícil tarea de dar nombres diferentes a operaciones similares. Las operaciones similares pueden tener un mismo nombre sin que haya conflictos, siempre y cuando se defina apropiadamente la sobrecarga de las funciones correspondientes.

Sobrecarga de Operadores
La sobrecarga de operadores, de modo similar que la sobrecarga de funciones, permite al programador dar nuevos significados a los símbolos de los operadores ya existentes en C++ para tipos de datos abstractos (tipos de datos definidos por el programador).
El resultado puede ser la creación de un código más facil de leer y depurar, con la desventaja de que si no se utiliza con el cuiadado suficiente pueden producirse graves problemas a sus programas.
La sobrecarga es una de las características más importantes de C++ y de la programación orientada a objetos. Con ella se puede redefinir el lenguaje C++ y proporciona a los programadores una herramienta que les facilitará manipular los tipos definidos por el usuario y nuevos tipos de datos abstractos de igual forma como se hace con los tipos incorporados al lenguaje.
Así por ejemplo, se pueden utlizar expresiones tales como:

objeto_1 = objeto_1 + objeto_2;
objeto_1 = objeto_1 * objeto_2;

Operadores que se pueden sobrecargar
Unarios ++ , --
Binarios / , % , () , [] , new , delete , += , -= , *= , /= , | , ^ , || , && , < , <= , > , >= , << , >> , |= , ^= , &= , <<= , >>= , == , = , -> , = , %= , Ž , ->*
Unarios o Binarios + , - , * , &

No está por demás mencionar que un operador unitario actúa sobre un sólo objeto y un operador binario sobre dos objetos.
Operadores que no se pueden sobrecargar . , .* , :: , ?: , sizeof
La sobrecarga de un operador es una función incoporada a C++ que permite al programador sustituir alguno de los operadores ya existentes por una función definida por el usuario. Las funciones operadoras sobrecargadas se eligen por el compilador utilizando el mismo mecanismo que se utiliza para elegir entre diferentes funciones sobrecargadas. Cuando se encuentra un operador no intrínseco, el compliador busca una función operador busca una función operador que tenga parámetros que correspondan con los operandos que se encuentran. Las funciones operador tienen la misma prioridad que las operaciones intrínsecas que utilizan el mismo operador. Por ejemplo: wl operador * siempre tiene mayor prioridad que el operador +.

Restricciones en los operadores sobrecargados
1.- Sólo se pueden sobrecargar operadores definidops en C++.
2.- La sobrecarga de operadores sólo funciona con objetos del alguna clase.
3.- No se puede cambiar la preferencia o asiciatividad de los oeradores definidos en C++.
4.- No se puede hacer funcionar a un operador binario como unitario ni viceversa.
5.- No se puede sobre cargar un operador que funcione exclusivamente con apuntadores.
6.- Es responsabilidad del programador definir correctamente el significado de las funciones sobrecargadas.
7.- No se pueden derivar operadores sobrecargados complejos de otros más simples. Por ej: Si se definen operator* y operator= y se desea realizar a*=b, es necesario sobrecargar el operador *=.

Mecanismo de sobrecarga de operadores
El formato general de la sobrecarga de un operador es:

tipo nombre_clase :: operator <op> (lista_de_args) { . . . }

tipo es tipo de valor devuelto por la operación especificada (función operador).
<op> es el operador que se está sobrecargando.
Las funciones operador deben ser miembros o amigas de la clase que se está utilizando.

Sobrecarga de operadores unitarios
Ejemplo:

class vector {
double x, y;
public:
vector (double xi, double yi) { x=xi; y=y1; }
void Visualizar() { cout << "Vector x= " << x << " y = " y; }
doble operator++()
{x++; y++;}
};
void main(void)
{ vector v1(10.5, 20.6);
v1.Visualizar();
v1++;
v1.Visualizar();
}

Con v++; se llama la función operator++() que incrementa los datos del objeto vector v1 en 1.

Sobrecarga de los operadores ++ y -- en forma prefija y posfija
La versión posfija de los operadores ++ y -- sobrecargados dentro de una clase recibe un argumento int, mientras que la versión prefija no.
Ejemplo:

class vector {
int x, y;
public:
vector() {x=0; y=0; }
vector& operator++() { x+=2; y+=2; return this; } //prefija
vector& operator++(int) { x++; y++; return this; } //posfija
ImprimeVector() { cout << "v " << x << " " << y << endl; }
} ;
void main(void)
{
vector v1;
v1++; // Se ejecuta el método operator++(int)
v1.ImpVector();
++v1; // Se ejecuta el método operator++()
v1.ImpVector();
v1=v1.operator++(); //Equivale a ++v1;
v1.ImpVector();
v1=v1.operator++(1); //Equivale a v1++;
v1.ImpVector();
}

Sobrecarga de operadores unitarios que no son miembros de alguna clase

class vector {
Int x, y;
public:
vector() {x=0; y=0; }
void Incrementa(int incr) { x+=incr; y+=incr; }
ImprimeVector() { cout << "v " << x << " " << y << endl; }
} ;
//posfija
vector& operator++(vector& vaux, int ) { vaux.Incrementa(1); return vaux; }
//prefija
vector& operator++(vector& vaux) { vaux.Incrementa(2); return vaux; }
void main(void)
{
vector v1;
v1++; // Se ejecuta la función operator++(int)
v1.ImpVector();
++v1; // Se ejecuta la función operator++()
v1.ImpVector();
v1=operator++(v1); // Equivale a ++v1;
v1.ImpVector();
v1=operator++(v1, 0); //Equivale a v1++;
v1.ImpVector();
}

Sobrecarga de operadores binarios
Los operadores binarios se pueden sobrecargar tan fácilmente como los operadores unitarios.
Ejemplo:

class vector {
int x, y;
public:
vector(int xi = 0, yi = 0) {x = xi; y = yi; }
ImprimeVector() { cout << "v " << x << " " << y << endl; }
vector operator+(vector v) { vector vaux; vaux.x= x + v.x; vaux.y = y + v.y; return vaux; }
vector& operator-(vector& v) { vector vaux= new vector; vaux->x= x - v.x; vaux->y = y - v.y; return vaux; }
};
void main(void)
{
vector v1, v2(2,3), v3(4,6);
v1 = v2 + v3; //Se ejecuta el método operator+(vector v)
v1.ImpVector();
v1 = v2 - v3; //Se ejecuta el método operator-(vector &v)
v1.ImpVector();
}

Sobrecarga del operador de asignación

class vector {
int x, y;
public:
vector() {x=0; y=0; }
vector(int xi = 0, yi = 0) {x = xi; y = yi; }
vector& operator=(vector& v) {x=v.x; y=v.y; return *this; }
void Incrementa(int incr) { x+=incr; y+=incr; }
ImprimeVector() { cout << "v " << x << " " << y << endl; }
} ;
void main(void)
{
vector v1, v2(2,3), v3(4,6);
v1 = v2 ; //Se ejecuta el método operator=(vector v&)
v1.ImpVector();
v1 = v3; //Se ejecuta el método operator=(vector &v)
v1.ImpVector();
}

Sobrecarga del operador de llamada a función ( ) y el operador subíndice [ ]
La llamada a función se considera como un operador binario.
La función operador correspondiente es operator() y puede ser definida por elusuario para una clase (y cualquier clase derivada) sólo mediante una función miembro no estática.
El operador [ ] se utiliza normalmente como índice.

Ejemplo:

class string {
char sPtr;
int length;
public:
String(const String &); // Constructor
String &operator() (int, int); //regresa un substring
char &operator[](int); //regresa una referencia a char
};
String::String(const char s) { length=strlen(s); sPtr= new char[length+1]; strcpy(sPtr, s); }
char * String::operator()(int c) { return(strchr(sPtr, c)); }
char & String::operator[](int i) { return sPtr[i]; }
void main(void)
{
String s1("Hola Mundo!");
cout <};

TEMPLATES (PLANTILLAS)
C++ tiene una característica llamada template que permite crear tipos parametrizados o declarar una familia completa de clases o funciones en lugar de sólo una.

Clases Genéricas
El propósito de la genericidad es definir una clase o una función sin especificar el tipo de uno o más de sus miembros (parámetros). A una clase de este tipo se le llama clase contenedora. La genericidad se puede emular utilizando herencia y polimorfismo,A continuación veremos un

Ejemplo.

#include
#include
#include
class ObjetoGenerico {
public:
virtual void Dibuja() {};
};
class Circulo : public ObjetoGenerico {
int x, y, r;
public:
Circulo(int xi=100, int yi=100, int ri=100) { x=xi ; y=yi; r=ri;}
void Dibuja() { circle(x, y, r); }
};
class Elipse : public ObjetoGenerico {
int x, y, rx, ry;
public:
Elipse(int xi=100, int yi=100, int rxi=60, int ryi=80) { x=xi; y=yi; rx=rxi; ry=ryi; }
void Dibuja() { ellipse(x, y, 0, 360, rx, ry) ; }
};
class Rectangulo : public ObjetoGenerico {
int xizq, yarriba, ancho, alto;
public:
Rectangulo(int xi=10, int yi=10, int an=40, int al=60) { xizq=xi; yarriba=yi;ancho=an; alto=al; }
void Dibuja() { rectangle(xizq, yarriba, xizq+ancho, yarriba+alto); }
};
class Nodo {
ObjetoGenerico figura;
Nodo sig;
public:
Nodo(ObjetoGenerico fig) { figura=fig; }
Nodo RecuperaSiguiente() { return sig; }
void PonerSiguiente(Nodo nodosig) { sig=nodosig; }
void Muestra(){ figura->Dibuja(); }
};
class Lista {
Nodo cabeza;
public:
Lista(){ cabeza=new Nodo(NULL); cabeza->PonerSiguiente(NULL); }
void Insertar (ObjetoGenerico fig);
void Desplegar();
};
void Lista::Insertar(ObjetoGenerico fig)
{
Nodo aux;
for(aux=cabeza; aux->RecuperaSiguiente()!=NULL; aux=aux->RecuperaSiguiente());
Nodo nuevo = new Nodo(fig);
nuevo->PonerSiguiente(NULL);
aux->PonerSiguiente(nuevo);
}
void Lista::Desplegar()
{ Nodo aux;
for(aux=cabeza->RecuperaSiguiente(); aux!=NULL; aux=aux->RecuperaSiguiente())
aux->Muestra();
}
void main()
{
int graphdriver = DETECT, graphmode;
initgraph(&graphdriver, &graphmode, "..\\bgi");
Lista ListaFig;
Circulo c1 = new Circulo(50,50,80);
ListaFig.Insertar(c1);
Elipse e1 = new Elipse;
ListaFig.Insertar(e1);
Rectangulo r1 = new Rectangulo(30,50);
ListaFig.Insertar(r1);
ListaFig.Desplegar();
closegraph();
}

Templates en funciones
Los templates nos proporcionan una solución elegante que nos evita escribir varias veces el mismo código para una función. Especifica un conjunto infinito de funciones sobrecargadas, pero permitiendo realizar la verificación de los tipos efectuados por C++.

Formato:
template declaración o definición de funciones
Los paramétros puden ser de dos categorías: tipos y constantes.
Los tipos se representan poneindo el prefijo class. Sin el prefijo, se trata de como constante.

Ejemplos:

template <class T>
template <int LongArray, int LongElem>
template <class TipoElem, long Longitud, class TipoComparador>

Ejemplo:

#include
template T min(T a, T b) { return a < b ? a: b; }
void main()
{ int ia=1, ib=5; cout << "Menor: " << min(ia, ib) << endl;
char la=a, lb=n; cout << "Menor: " << min(la, lb) << endl;
float fa=88.4, fb=19.9; cout << "Menor: " << min(fa, fb) << endl;
}

Templates en clases
Nos permiten definir clases genéricas que pueden manipular varios tipos de datos. Son útiles para implementar contenedores que son clasesque contienen objetos de un tipo dado: las clases contenedores permiten administrar listas ligadas de objetos, tablas cuyo tamaño puede variar dinámicamente, conjuntos, etc.

Ejemplo:

#include
template class stackvector {
T *data;
int tope;
unsigned int size;
public:
stackvector (unsigned int tam);
T pop();
void push(T value);
};
template stackvector :: stackvector(unsigned int tam): size(tam)
{ data = new T[size]; tope = size +1; }
template void stackvector :: push(T val)
{ if ( tope == 1) cout << "Pila llena";
else data[--tope]=val;
}
template void stackvector :: pop()
{ if (tope == (size+1) return -1;
else return data[tope +1];
}
void main()
{
stackvector st(5);
st.push(5);
st.push(3);
st.push(2);
for(i=0; i<3; i++) cout << " " << st.pop();
stackvector st(6);
st.push(3.1416);
st.push(1.7178);
st.push(0.0001);
st.push(12345.123);
for(i=0; i<3; i++) cout << " "<< st.pop();
}

Ejemplo:

class alfa {
public:
double suma; //funciones púlicas
};
class beta: public alfa {
public:
int n; //funciones públicas
};

Clases de Derivación

Derivación públca (public clase base)
Todos los miembros public y protected de la clase base son accesibles en la clase derivada, mientras que los miembros private de la clase base son inaccesibles en la clase derivada.

class Base {
public:
void f();
int a, b;
private:
float c, d;
};
class Derivada: public Base {
public:
void g();
};
void main()
{ Derivada d;
d.a=50;
d.b=100;
d.f();
d.c=100; //Error: miembro privado de la clase base
}

Derivación Privada (private clase base)
Todos los miembros de la clase base se comportan como miembros privados de la clase derivada. En este caso, los miembros public y protected de la clase base no son accesibles mas que por las funciones miembro de la clase derivada. Los miembros privados de la clase base siguen siendo incaccesibles desde la clase derivada.

class Base {
public:
void f1();
void f2();
int a, b;
private:
float c, d;
};
class Derivada: private Base {
public:
Base::f1(); //acceso autorizado de modo explícito
Base::a;
};
void main()
{ Derivada d;
d.a =50; //Válido
d.b=100; //Error, acceso prohibido
d.f1(); // Válido
d.f2(); //Error, acceso prohibido
d.c=100, //Error, miembro privado de la clase
}

Derivación protegida (public clase base)
Se utiliza de modo similar a la derivación private. Todos los miembros public y protected de la clase base se comportan como miembros protected en la clase derivada. Estos miembros no son pues, accesibles al programa exterior, pero las clases que se deriven a continuación podrán acceder normalmente a estos miembros.

class Derivada: protected Base {
public:
// ...
};

Ventajas e inconvenientes de la derivación privada y protegida
Las derivaciones private y protected son útiles cuando se desea asegurar que solamente la interfase de nuestra clase derivada pueda ser utilizada por el programa principal y/o por las otras clases derivadas de ésta.
Como inveconvenientes, la utilización de las derivaciones private y protected complican el árbol de herencia, volviéndose más compleja la determinación de derecho de acceso. a los miembros de cada clase, a partir de la simple lectura de su programa.
Es aconsejable usar estos dos tipos de derivación en que puedan existir razones de peso para su uso. Cuando no se utiliza un especificador de acceso, C++ considera por defecto una derivación privada.

class Derivada: Base { //La derivación es privada por defecto
public:
// ...
};

Jerarquia de Clases

class ObjetoGenerico {
public:
virtual void Dibuja() {};
};
class Circulo : public ObjetoGenerico {
int x, y, r;
public:
Circulo(int xi=100, int yi=100, int ri=100) { x=xi ; y=yi; r=ri;}
void Dibuja() { circle(x, y, r); }
};
class Elipse : public ObjetoGenerico {
int x, y, rx, ry;
public:
Elipse(int xi=100, int yi=100, int rxi=60, int ryi=80) { x=xi; y=yi; rx=rxi; ry=ryi; }
void Dibuja() { ellipse(x, y, 0, 360, rx, ry) ; }
};
class Rectangulo : public ObjetoGenerico {
int xizq, yarriba, ancho, alto;
public:
Rectangulo(int xi=10, int yi=10, int an=40, int al=60) { xizq=xi; yarriba=yi; ancho=an; alto=al; }
void Dibuja() { rectangle(xizq, yarriba, xizq+ancho, yarriba+alto); }
};

Herencia Multiple
La herencia múltiple es la propiedad con la cual una clase derivada puede tener más de una clase base o padre. También se conoce como derivación de clase con clase base múltiple.

class ObjetoGenerico {
public:
virtual void Dibuja() {};
};
class PropiedadesGenerales {
protected:
char etiqueta[32];
public:
char TipoFigura[32];
void PonerTipoFigura(int tipo) {
if(tipo == 1) strcpy((char )TipoFigura, (const char )"Circulo");
if(tipo == 2) strcpy((char )TipoFigura, (const char )"Elipse");
if(tipo == 3) strcpy((char )TipoFigura, (const char )"Rectángulo");
}
};
class Circulo : public ObjetoGenerico, public PropiedadesGenerales {
int x, y, r;
public:
Circulo(int xi=100, int yi=100, int ri=100, char etiq) { x=xi ; y=yi; r=ri;
strcpy((char )etiqueta, (const char )etiq); }
void Dibuja() { circle(x, y, r); }
};
void main()
{
Circulo c1 = new Circulo(50,50,80, "MiCirculo");
c1->PonerTipoFigura(1);
}

Ambigüedades en herencia multiple
Una de las ambigüedades más comunes se da cuando dos clases base tienen funciones cn el mismo nombre, y sin embargo, una clase derivada de ambas no tiene una función con ese nombre. Para resolver la ambigüedad se usa el operador de ámbito.

class A {
public:
void mostrar() { cout << "\n Clase A"; }
};
class B {
public:
void mostrar() { cout << "\n Clase B"; }
};
clase C : public A, public B
{ };
void main()
{
C obietoC; // Se crea un objeto de la clase C
objetoC.mostrar( ) // Error. Se tiene ambigüedad
objetoC.A::mostrar( ); // Correcto
objetoC.B::mostrar( ); // Correcto
}

Constructores y destructores en herencia múltiple
Durante la construcción de un objeto perteneciente a una clase derivada , se llaman sucesivamente los constructores de sus clases base en el orden de sus declaraciones. Al final se llama el constructor de la clase derivada.

class A {
protected:
int x;
void f(int i) { x = i ; }
public:
A(int a = 1) { x = a ; }
};
class B {
protected:
int y;
void g(int i) { y = i ; }
public:
B(int b = 1) { x = b ; }
};
class C: public A, public B {
protected:
int z;
void h(int i) { cout << x << " " << y << " " << z ; }
public:
C(int c = 1) ;
};
C::C(int c) : A( 2 * a ) , B( 3 * a)
{
x = c ;
}
void main()
{
C ObjetoC(5) ;
ObjetoC.h() ;
}