C/Visual C - Sobrecarga de operadores

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.

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?

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.

Bueno, y en el atributo privado, se me olvido declarar la matriz como:

float matriz[5][5];

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;
}

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.

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.

Muchas gracias por sus respuestas a ambos, me fueron de gran ayuda. Saludos.