Foro de elhacker.net

Hola, estoy practicando el tema de sobrecarga y me tope con 2 problemas. :silbar:

class Foo
{
public:
	//Foo& operator+(const Foo& f); tampoco funciona
	//Si funciona (Foo& f)
	Foo& operator+(Foo const& f){
		bar_ += f.getBar();
		return *this;
	}
	int getBar(){
		return bar_;
	}
private:
	int bar_;
};
 

Por alguna razon, cuando sobrecargo el operador +, Visual Studio 2010 me exigue que el parametro sea una referencia simple "Foo& f" y no const. Si coloco const, salta error que no puede convertir de const & a & desde el metodo Foo::getBar().
No tengo visual studio a mano como pasar el error exacto.
(passing `const Foo' as `this' argument of `int Foo::getBar()' discards qualifiers )

Otra cosa, en http://www.parashift.com/c++-faq/overview-op-ov.html
Coloca este ejemplo
Pero vc++ y blodshed dev c++ tambien se quejan de que solo se puede pasar un argumento a un operador unario.

Será que tiene solamente parcial soporte de c++11?

Saludos y Gracias

getbar no es const, no puedes llamar a un método "no const" desde una referencia "const".

Por otro lado, el otro ejemplo que has puesto:

Fred operator+ (Fred const& x, Fred const& y);

Este ejemplo únicamente compila si el operador se sobrecarga fuera de la clase "Fred". Eso sí, para asegurar un funcionamiento óptimo lo suyo es hacer que este método sea "friend" de la clase "Fred".

Muchas gracias :)

Tiene sentido si se toma "Foo const& f" como referencia a Foo constante, all llamar a  algun metodo de f, es posible que este modifique el objeto.

Entonces, "const Foo& f" es lo mismo que "Foo const&  f"?

Hay alguna manera de hacer "constante referencia  a Foo" y no "referencia a Foo constante"?

Me refiero a :

void f(foo "referencia constante a" f){
        f = foo(); //error, f referenciaria otro objeto
        f.set(valor); //ok, f sigue referenciando a f pero con un miembro cambiado de valor.
}
 

Es decir, que se pueda cambiar los miembros de la referencia, pero no la referencia.

PD, creo que correctamente seria asi el la sobrecarga de +?

Foo operator+(const Foo& f)
{
        Foo b;
	b.bar_ = this->bar_ + f.bar_;
	return b;
}
 

Y tambien, + tendria que devolver objeto  nuevo mientras que += referencia al objeto?

Foo operator+(const Foo& f);
Foo& operator+=(Foo const& f);
 

Saludos y Gracias.

Es lo mismo sí.


Foo& variable -> "constante referencia a Foo"
const Foo& variable -> "referencia a Foo constante"

Cuando declaras una referencia, el compilador te obliga a darle un valor en ese mismo momento. Despuées de la inicialización, verás que no vas a poder modificar la referencia. Es decir, el enlace de referencia es constante siempre. Debido a esto, el modificador "const" únicamente tiene sentido si amplía la cobertura... y de la única forma en la que puede hacer esto es haciendo que la clase o variable sea de solo lectura.


Es una forma de implementarlo... ahora, si Foo tiene un constructor que permite inicializar "bar_", es un poco más eficiente llamar a dicho constructor:

Foo operator+(const Foo& f) const
{
        return Foo{ bar_ + f.bar_ };
}

Por cierto, nota el "const" de la función... los operadores que no tienen el igual no deberían modificar la instancia actual y deberían, por tanto, ser "const". Puede parecer una tontería, pero ya has visto que si un miembro no tiene el modificador "const" no puedes usarlo en una función "const".


A ver, el operador "+" tiene que devolver un objeto nuevo porque, como te he comentado antes, este operador no debe modificar la instancia actual. Crear un objeto nuevo responde a la necesidad de devolver el resultado en un objeto que no sea el actual.

El operador "+=" si que tiene que modificar la instancia actual y, dado que al finalizar la función la instancia actual tendrá el valor bueno, suele ser más eficiente devolver una referencia que crear un objeto nuevo basado en el valor actual.

Espero haberte resuelto las dudas.

Un saludo.

Muchas gracias eferion :D

Me has sacado un monton de dudas y puntos de foco debiles  ;-)


Gracias nuevamente :)

Y pueden dar por cerrado el tema ^^