C/Visual C - Sobrecarga de operadores

   
Vista:

Sobrecarga de operadores

Publicado por Mefistófeles (4 intervenciones) el 14/08/2008 02:40:34
Hola que tal amigos, disculpen lo que pasa es que llevo mi materia de programación orientada a objetos en C++, y hubo un problema que dice así:

Realice la función de sobrecarga del operador suma(+) para que determine y devuelva la suma de dos matrices de elementos tipo flotane de tamaño 5x5 cotenidos en una clase.

Me podrían ayudar con ese problema por favor, y darme una breve explicación??. Se los agradecería mucho.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

RE:Sobrecarga de operadores

Publicado por Gilberto (31 intervenciones) el 14/08/2008 05:54:44
Depende de cómo implementes la clase de la matriz, y si la función va a ser miembro o friend, aunque en general la cabecera es así:

public Tipo_Retorno operator+(Tipo var) {
...
}

antes hay que declarar la función dentro del cuerpo de la clase:

class Clase {
...
public:
Tipo_Retorno operator(Tipo var);
...
};

puedes pubicar el código de la clase, para ayudarte un poco más?
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por Mefistófeles (4 intervenciones) el 14/08/2008 08:24:26
Muchas gracias por responderme amigo.

Si bueno, en la clase tenía pensado implementarlo como un atributo privado de la siguiente manera:

class matrices{
private:
matriz[5][5];
public:
matrices operator+(& mat)
{
//cuerpo de la funcion
}
//otros métodos
};

int main( )
{
matrices arreglo1, arreglo2, arreglo3;

arreglo3 = arreglo1+arreglo2;

return 0;
}

Bueno, eso es el código a grandes rasgos que yo realize, porque en sí lo que me piden es solo la función de sobrecarga del operador +.

1. ¿Está bien que la función de sobrecarga regrese un valor del tipo de la clase?.
2. ¿Es correcta la declaración de la matriz en el atributo privado?
3. ¿Es obligatorio que la función de sobrecarga reciba parámetros por referencia, o también puede recibir parámetros por valor, cuál es la diferencia?
4. ¿Cuál es la diferencia entre declarar la función como método y declararla como friend?

Y bueno, mi última pregunta es como sería el cuerpo de la función de sobrecarga.

Perdón si tengo muchas dudas, pero es que la maestra que me dio la materia solo me hizo bolas. Te agradecería mucho si me explicaras amigo. Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por Mefistófeles (4 intervenciones) el 14/08/2008 08:28:20
Bueno, y en el atributo privado, se me olvido declarar la matriz como:

float matriz[5][5];
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por Gilberto (31 intervenciones) el 16/08/2008 15:27:23
1.- Es correcto como o tienes escrito ya que una copia del valor devuelto es asignada en operaciones de asignación, como:

matriz a(valores de inicio);
matriz b(valores de inicio);
matriz c = a+b;

2.- Es correcta pero no recomendable poner directamente literales en indices de arreglos (entre otros), mas bien se usa el poner constantes simbólicas como :

const int FILAS = 5;
const int COLS = 5;

en algún otro lugar y declarar el arreglo

float matriz[COLS][FILAS];

Además hay que inicializar el arreglo, un buen lugar es el constructor de la clase:

matrices()
{
...
maitriz = new float[COLS][FILAS];
...
}

3.- Es correcto, la diferencia está en que se ocupa más memoria, ya que los parámetros por valor se copian para usar en la función, y en los parámetros por referencia no es así, se usa el objeto originalmente referenciado.

4.- Esencialmente no hay diferencia ya que las funciones friend pueden tener acceso a los miembros privados de la clase. La diferencia se da cuando sobrecargas un operador con un operando que no es un objeto de la clase, como en la siguiente hipotetica función para multiplicar una constante por los elementos de una matriz:

float PI= 3.1416;
matrices m(valores de inicio);
matrices n = PI*m;

no hay forma de implementar esto como una función miembro, porque para invocar la función miembro se necesita un objeto del lado izquierdo del operador, por lo que esta función se impementa como friend.

Esquemáticamente el cuerpo sería:

public matrices operator+(matrices& m)
{
matrices res; // matriz que guarda el resultado de la suma

// algoritmo para sumar las matrices, los miembros de el objeto anfitrión (host) se
// invocan directamente, los de la matriz pasada en el argumento se invocan en la
// forma m.miembro

return res;
}
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por Gilberto (31 intervenciones) el 16/08/2008 17:52:27
Por supuesto, en el punto 4, la función miembro si se puede implementar, pero para invocarla se tiene que escribir con el operando izquierdo del operador siendo un objeto de la clase:

loat PI= 3.1416;
matrices m(valores de inicio);
matrices n = m*PI;

pero esto limita un poco la escritura de expresiones, ya que debemos conocer cómo se implementa un operado sobrecargado para no cometer un error. En cambio, con la función friend, se escriben ámbas versiones de los argumentos (o sea, una versión con los operandos en un orden de invocación y la otra versión con los operandos al en orden invertido):

public matrices operator*(matrices m,double v)
{
...
}

public matrices operator*(double v,matrices m)
{
...
}

Si los operandos son del mismo tipo, no es necesaria la implementación friend, ya que en cualquier orden, se invoca el método correcto.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por fernando.gomez (1604 intervenciones) el 17/08/2008 08:01:36
Yo lo haría así:

template<class T>
vector<T> operator+(const vector<T>& v1, const vector<T>& v2)
{
vector<T> v;

if (v1.size() != v2.size())
throw exception("Los vectores deben tener el mismo tamaño.");

for (int i = 0; i < v1.size(); i++)
v.push_back(v1[i] + v2[i]);

return v;
}

int main()
{
vector<int> v1;
vector<int> v2;
vector<int> res;

v1.push_back(1);
v1.push_back(2);
v1.push_back(3);
v2.push_back(4);
v2.push_back(5);
v2.push_back(6);

res = v1 + v2;

for (vector<int>::iterator i = res.begin(); i != res.end(); ++i)
cout << *i << endl;

return 0;
}

El programa anterior (si no me equivoqué, no lo he probado) debería dar el siguiente resultado:

5
7
9

Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

RE:Sobrecarga de operadores

Publicado por Mefistófeles (4 intervenciones) el 26/08/2008 04:33:10
Muchas gracias por sus respuestas a ambos, me fueron de gran ayuda. Saludos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar