Programacin I

Actividad 18 Conferencia # 10 Homonimia de operadores.

SUMARIO:
-

Implementacin de la homonimia de funciones.

Ejemplo: Clase Array.

BIBLIOGRAFA:
LT Tomo 3 captulo 18. LT Tomo 3 captulo 18. Ejercicios 18.9, 18.15, 18.20.
TRABAJO PREVIO:
Ejercicio 18.20 del libro de texto.
OBJETIVOS
Que los estudiantes conozcan como se programa la homonimia de operadores as como las ventajas desde el
punto de vista del programador usuario de clases.
Preguntas:
1- Qu es la homonimia de operadores?
2- Cundo es til y cuando no? Cules son las ventajas?
3- De cuantas formas se puede sobrecargar un operador?
Definicin de la clase/Rol PC.
class Array {
friend ostream &operator<<(ostream &,
const Array &);
public:
Array(int=10);
Array(const Array&);
~Array();
int getSize() const;
const Array& operator=(const Array&);
int operator==(const Array&) const;
int& operator[](int);
int& operator!(int);
private:
int *ptr;
int size;
};
Array::~Array(){
delete [] ptr;
}

Array::Array(int arraySize){
size = arraySize;
ptr = new int[size];
assert(ptr != 0);
for (int i=0; i < size; i++)
ptr[i] = 0;
}
int& Array::operator[](int subscript){
assert(0 <= subscript && subscript < size);
return ptr[subscript];
}

int Array::getSize() const{

return size;
}
Conf # 1 Pg 1 de 3

Segmento de programa/Rol PUC.

{
Array a1(3); // el compilador invoca al constructor.
a1[0] = 1; // este proceso se divide en dos pasos:
// El compilador invoca automticamente al destructor de la clase pues la variable tienen un
// mbito de bloque.

Objeto a1
ptr-> 0
0

1- Se invoca la funcin miembro a1.operator[](int) y se crea una referencia temporal al

primer elemento del arreglo. Internamente sera algo como esto:
a. int& temp = ptr[0];
2- Luego se aplica la asignacin temp = 1 con lo cual se modifica el primer elemento del
arreglo interno, pues la variable temporal es una referencia.

Rol/PC
ostream &operator<<(ostream &output,
const Array &a){
for (int i=0; i < a.size; i++)
output << a.ptr[i] << ' ';
output << endl;
return output;
}

Rol PUC.
{
Array a1(3), a2(5);
a1[0] = 1;
a2[3] = 8;
cout << a1 << a2;
}
Se invoca primero:
1-operator<<(cout, a1);
2-operator<<(cout, a2);
En realidad lo que ocurre es:
operator<<( operator<<(cout, a1), a2);

Array::Array(const Array& init){

size = init.size;
ptr = new int[size];
assert(ptr != 0);
for (int i=0; i < size; i++)
ptr[i] = init.ptr[i];

{
:
:
Array a3 = a2; se invoca al constructor de copia
cout << a3 << a2;
}

Conf # 1 Pg 2 de 3

const Array& Array::operator=(const Array& right){

if (&right != this) {
delete [] ptr;
size = right.size;
ptr = new int[size];
assert(ptr != 0);
for (int i=0; i < size; i++)
ptr[i] = right.ptr[i];
}
return *this;
}

{
:
a2 = a1;
}
Se invoca al operador de asignacin sobrecargado.
Esta funcin realiza la copia de un objeto a otro, de
forma semnticamente correcta.

{
int Array::operator==(const Array& right) const{
if (size != right.size)
return 0;
for(int i=0;i < size; i++)
if (ptr[i] != right.ptr[i])
return 0;
return 1;
}
Array& Array::operator!(){
for (int i=0,j=size-1; i < size/2; i++, j--){
int temp = ptr[i];
ptr[i] = ptr[j];
ptr[j] = temp;
}
return *this;
}

:
if (a1 == a2)
cout << los arreglos son idnticos;
else
cout << los arreglos no son idnticos;
}
La operacin if (a1 == a2) es ejecutada por el
compilador como: if ( a1.operator(a2) )
{
:
!a1;
cout << a1;
}
Se imprime el arreglo invertido. a1 es lo mismo que
una llamada a a1.operator!()
Si se aplicara !!a1 el resultado sera lo mismo que a1,
por que se aplica la operacin dos veces y como es
simtrica no tiene efecto visible para el usuario de
programa. El compilador efectua lo siguiente:
a1.operator !().operator !();
El resultado de a1.operator !() es una referencia a a1,
por lo tanto se volver a modificar el propio objeto.

Conclusiones

Conf # 1 Pg 3 de 3