Clase 8: Sobrecarga
CONTENIDO
Sobrecarga de Funciones
Constructores Copia
Sobrecarga de operadores
Sobrecarga de operadores
SOBRECARGADO DE FUNCIONES
Consiste en crear diferentes funciones
con el mismo nombre, con el fin de
ofrecer al usuario una manera ms
sencilla de recordar las funciones.
//Algunos protototipos
int funcion(int);
int funcion(long, long);
int funcion(long);
SOBRECARGADO DE FUNCIONES
Cuando se realiza la invocacin de una
funcin sobrecargada, el compilador
decide cual de ellas se utilizar mediante
un proceso denominado resolucin de
sobrecarga ("Overload resolution").
Se resuelve aplicando ciertas reglas para
verificar cual de las declaraciones se
ajusta mejor al nmero y tipo de los
argumentos utilizados.
4
SOBRECARGADO DE FUNCIONES
El proceso sigue unas reglas en el orden
precedencia sealado:
Concordancia exacta en nmero y tipo.
Concordancia
promociones
de
los
asimilables.
tipos
Ejemplo:char,short,bool,aint.
SOBRECARGADO DE LOS
MTODOS DE LAS CLASES
Los mtodos de las clases tambin pueden ser
sobrecargados como el resto de las funciones,
su sintaxis es prcticamente igual.
class Rectangulo
{
public:
// funcin DibujarFigura sobrecargada de la clase
void
DibujarFigura() const;
void DibujarFigura()
const;
void
DibujarFigura(int unAncho,
void DibujarFigura(int
unAncho, int
int unaAltura)
unaAltura) const;
const;
private:
int suAncho;
int suAltura;
};
6
SOBRECARGADO DE LOS
MTODOS DE LAS CLASES
Los constructores, al ser mtodos
especiales de las clases tambin pueden
ser sobrecargados, y la manera de
hacerlo es igual que el resto de los
mtodos.
OJO!, los destructores no pueden ser
sobrecargados, Porque?
EJEMPLO SOBRECARGA
class carro{
private:
int gGas;
char *marca;
int velMax;
int vel;
bool start;
public:
void carro::acelerar(){
carro::carro(){
gGas=0;
if(--gGas<=0){
marca=0;
vel=0;
velMax=0;
}
vel=0;
else{
start=false;
vel++;
} }
}
carro();
carro(int _gGas,char *_marca="mazda",\
int _velMax=80);
void arrancar();
carro::carro(int
void
carro::acelerar(int
_gGas,char
increment){
*_marca, int
void acelerar();
_velMax){
if(--gGas<=0){
void acelerar(int increment);
gGas=_gGas;
vel=0;
void frenar();
marca=_marca;
}
int getVel() const;
velMax=_velMax;
else{
~carro();
vel=0;
vel+=increment;
};
} }
}
carro Deportivo(10,"Renault");
10
VALORES DE RETORNO
Con el fin de que el mecanismo de
sobrecarga
sea
independiente
del
contexto, los valores devueltos por las
funciones NO son tenidos en cuenta a
efectos del mecanismo de sobrecarga.
int func (int, char);
int func (float, char);
void func (int, char);
11
CONTENIDO
Sobrecarga de Funciones
Constructores Copia
Sobrecarga de operadores
Sobrecarga de operadores
12
CONSTRUCTORES COPIA
Adicionalmente de ser asignado por defecto un
constructor y un destructor cuando no son declarados
explcitamente en la declaracin de la clase, el
compilador provee un constructor de copia, que es
llamado cada vez que se requiere una copia de un
objeto.
#include <iostream>
using namespace std;
carro Deportivo(10,"BMW",50);
//carro carreras=Deportivo;
carro carreras(Deportivo); //constructor copia por
defecto
int main()
{
50
cout<<Deportivo.getVelMax()<<endl;
50
cout<<carreras.getVelMax()<<endl;
return 0;
}
13
CONSTRUCTORES COPIA
Cada vez que se crea una copia de un
objeto "El constructor de copia es
ejecutado.
Por defecto, el constructor de copia
simplemente copia cada miembro de una
objeto hacia el nuevo objeto. Esta copia
se denomina Copia Superficial.
//Declaracin del constructor de copia
Nombre (tipo variable);
Constructor (const Clase &Objeto); // constructor de copia
14
CONSTRUCTORES COPIA
//Declaracin del constructor de copia
Rectangulo (const Rectangulo &refR);
15
CONSTRUCTORES COPIA
La copia superficial es buena para casi todo tipo
de variables; sin embargo, es muy fcil de romper
cuando los miembros son punteros a objetos en el
Heap.
16
CONSTRUCTORES COPIA
La solucin para evitar problemas ocasionados
por las copias superficiales, es usando los
constructores de copia para que estos hagan la
copia en diferentes espacios del Heap,
realizando lo que se denomina como Copia
Profunda.
17
CONSTRUCTORES COPIA
carro(carro &deportivo);
18
CONSTRUCTORES COPIA
delete gGas; }
gGas=0; //NULL
int main()
public:
}
{
carro();
cout<<Deportivo.getVelMax()<<endl; 50
carro(int _gGas,char *_marca,int
cout<<carreras.getVelMax()<<endl;
_velMax);
50
return
0; el constructor de copia.
//se declara
} carro(carro &original); //la variable constante debe ser inicializada en la
CONTENIDO
Sobrecarga de Funciones
Constructores Copia
Sobrecarga de operadores
Sobrecarga de operadores
21
SOBRECARGADO DE LOS
OPERADORES
La sobrecarga de operadores quiere decir que
se pueden redefinir algunos de los operadores
existentes en C++ para que acten de una
determinada
manera,
definida
por
el
programador, con los objetos de una clase
creada por el mismo.
FUNCION OPERADOR
Existen dos clases de sobrecargas:
De un operador
De dos operadores
23
FUNCION OPERADOR
Cuando
sobrecargamos
cualquier
operador nos referimos a cambiar su
funcionalidad pero
no
su
gramtica original.
As por ejemplo:
Suma: a + b; a+;
Asignacin: a = a+b; a + b = a;
24
SOBRECARGA DE
OPERADORES
Palabra
reservada
-, --, + , ++,
=, ==,
Void, int,
char,
FUNCION OPERADOR
As, cuando hacemos la sobrecarga de un
operador y realizamos su llamado nos
referimos a:
Expresin
Mtodo
Funcin
@a
a.operator@()
operator@(a)
a@b
a.operator@(b)
operator@(a,b)
a=b
a.operator=(b)
a[b]
a.operator[](b)
a->
a.operator->()
a@
a.operator@(0)
operator@(a,0)
26
FUNCION OPERADOR
Suponiendo que tenemos tres objetos de
una misma clase: c1, c2, c3
c3 = c1.suma(c2);
27
SOBRECARGA DE
OPERADORES
El objetivo de la sobrecarga de operadores
es simplificar al mximo el cdigo a
escribir.
A cambio agregar algunas definiciones en
las clases.
Una clase que disponga de operadores
sobrecargados es una clase ms compleja
de definir, pero ms sencilla e intuitiva de
utilizar.
28
void contador::setvariable(int
contador::contador():
variable(0){}
_variable){
variable=_variable;
//constructor de copia
}
int main()
class
contador{
contador::contador(contador& original){
{
private:
voidvariable=original.variable;
contador::incrementar(){
int
mycontador.incrementar();
variable;
} variable+=2;
cout<<"incremento utlizando un metodo:
} " \
2
public:
<< mycontador.getvariable()<<endl;
int contador::getvariable() const{
contador();
++mycontador;
return variable;
4
//constructor
cout<<"incremento
de copia
sobrecargando el operador
}
++:" \
contador(contador&
<<mycontador.getvariable()<<endl;
original);
int getvariable() const;
return
0;
void
setvariable(int
_variable);
} void incrementar();
//definicin de la sobrecarga del operador
//sobrecarga el operador
preincremento (++i)
//preincremento (++i)
void contador::operator++(){
void operator++();
variable+=2;
~contador();
}
};
//Destructor
contador::~contador(){}
29
using
//definicin
namespace std;
de la operador
preincremento
(++i)
contador
cont1;
contador::operator++
int contador
main()
(){
{
variable+=2;
cont1.incrementar();
contador temp;
cout<<"cont1:
" <<cont1.getvariable()<<endl;
temp.setvariable(variable);
contador
cont2=++cont1;
return temp;
cout<<"cont2:
"<<cont2.getvariable()<<endl;
}
cont1: 2
cont2: 4
return 0;
}
30
31
33
}
/* Notese el uso de la variable flag... dicha vble
es declarada pero nunca es utilizada!! */
34
Modificamos el valor de la
variable del objeto original.
35
class contador{
private:
contador cont1;
//Ejemplo
int variable;
operador posincremento
int main()
public:
cont1: 6
{ contador();
//constructor
cont1.incrementar();
de copia
void contador::incrementar(){
contador(contador&
cout<<"incremento original);
utlizando un//definicion
metodo:
variable+=2;
"<< de
cont1.getvariable()<<endl;
la operador preincremento (++i)
int
contador
getvariable()
cont2=++cont1;
const;
} contador& contador::operator++(){
const
void
cout<<"El
setvariable(int
valor de cont1
_variable);
luego de preincremento
variable+=2;
"<<cont1.getvariable()<<endl;
void
incrementar();
return *this;
cout<<"El valor
de cont2:
"<<cont2.getvariable()<<endl;
//sobrecarga
el operador
preincremento
(+
}
cont2=cont1++;
+i)
const
cout<<"El
contador&
valoroperator
de cont2:
++();
"<<cont2.getvariable()<<endl;
//sobrecarga
cout<<"El valor
del operador
de cont1 posincremento
luego//definicion
de posincremento:
del operador posincremento (i++)
(i++)
"<<cont1.getvariable()<<endl; const contador contador::operator++(int
const contador operator ++(int flag);
flag){
~contador();
return 0;
//hace una copia del objeto
};}
contador temp(*this);
variable+=2;
return temp;
36
SOBRECARGA DE
OPERADORES
1
37
OPERADORES BINARIOS
Son aquellos que requieren
dos
operandos, como la suma o la resta.
Cuando se sobrecargan operadores en el
interior se asume que el primer operando
es el propio objeto de la clase donde se
define el operador. Debido a esto, slo se
necesita especificar un operando como
argumento.
38
SOBRECARGANDO EL
OPERADOR +
contador::contador():variable(0){}
int
contador::getvariable() const{
cont1: 5
return variable;
contador::contador(int
}
cont2:_variable):
6
variable(_variable){}
cont3: 11
void contador::setvariable(int _variable){
//constructor
variable=_variable;
de copia
contador::contador(contador& original){
}
variable=original.variable;
"<<cont1.getvariable()<<endl;
}
void
contador::incrementar(){
"<<cont2.getvariable()<<endl;
variable+=2;
"<<cont3.getvariable()<<endl;
}
class
contador{
//Ejemplo
operador +
private:
int main()
{ int variable;
public:
contador cont1(5),cont2(6);
contador();
contador cont3=cont1+cont2;
contador(int
_variable);
cout<<"el valor
de cont1 es:
//constructor
de de
copia
cout<<"el valor
cont2 es:
contador(contador&
cout<<"el valor de original);
cont3 es:
int getvariable() const;
void
setvariable(int
_variable);
return
0;
} void incrementar();
//sobrecarga el operador +
contador operator+(const contador&
//definicin del operador +
other);
contador contador::operator+(const contador&
~contador();
other){
};
contador temp;
temp.setvariable(variable+other.getvariable())
;
return temp;
}
39
SOBRECARGANDO EL
OPERADOR =
int main()
{
contador cont1(5),cont2(6);
cont2=cont1;
cout<<"el valor de cont1 es: "<<cont1.getvariable()<<endl;
cout<<"el valor de cont2 es: "<<cont2.getvariable()<<endl;
return 0;
}
SOBRECARGANDO EL
OPERADOR =
//sobrecarga el operador =
const contador& operator =(const contador& other);
//definicion del operador =
const contador& contador::operator =(const contador&
other){
if(this==&other){
return *this;
}
else{
variable=other.variable;
}
return *this;
}
41
BIBLIOGRAFA
Curso C++ con clase
http://c.conclase.net/curso/?cap=043
Pagina de Referencia lenguaje C++:
http://www.cplusplus.com/reference/std/ex
ception/exception/
http://www.cplusplus.com/reference/std/st
dexcept/
Sams Teach yourselft C++ in 21 days:
http://newdata.box.sk/bx/c/htm/ch20.htm#
Heading1
42
Fin de la clase!
43