3. ambiguous overloading

ambiguous overloading

  • G

    Ich habe in meiner Klasse Zugriffsoperatoren erstellt:

    template <class T>
T& Vector<T>::operator[](unsigned int index) {
	assert(index < this->m_vData.size() );

	return this->m_vData[index];
}

template <class T>
const T& Vector<T>::operator[](unsigned int index) const {
	assert(index < this->m_vData.size() );

	return this->m_vData[index];
}

    Nun habe ich von dieser Klasse abgeleitet und will diese Operatoren benutzen:

    template <class T>
Vec3<T>::Vec3(T init_x, T init_y, T init_z) {
	this->m_vData.resize(3);
	(*this)[0] = init_x; // FEHLER
	(*this)[1] = init_y; // FEHLER
	(*this)[2] = init_z; // FEHLER
}
/*
 * ODER SO
 */
template <class T>
Vec3<T> Vec3<T>::GetRotatedY(double angle) const
{
	assert(this->m_vData.size() == 3);

	if(angle==0.0)
		return (*this);

	float sinAngle=(float)sin(M_PI*angle/180);
	float cosAngle=(float)cos(M_PI*angle/180);

	Vec3<T> result(*this);
	result[0] = result[0]*cosAngle + result[2]*sinAngle; // FEHLER
	result[1] = result[1]; // FEHLER
	result[2] = -result[0]*sinAngle + result[2]*cosAngle; // FEHLER

	return result;
}

    Leider bekomme ich an jeder Stelle, in der ich die Dinger so anwende eine komische Meldung wie:

    ../src/math/Vec3.hpp:116: error: ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:
../src/math/Vector.hpp:179: note: candidate 1: T& MATH::Vector<T>::operator[](unsigned int) [with T = float]
../src/math/Vec3.hpp:116: note: candidate 2: operator[](float*, int) <built-in>
    0
  • P

    kann das sein dass du in der Klassendefinition von Vector<T> einen Konvertierungsoperator nach T* eingebaut hast? Falls ja: Weg damit!
    Der Compiler scheint nämlich ganz Standardkonform nicht entscheiden zu wollen, ob er lieber das Argument (ein int) in ein unsigned int konvertieren soll, oder ob er besser den Ausdruck result (den Vector<float> in deinem Fall) in ein float* konvertieren soll.

    0
  • G

    krass, ich habe so einen Operator eingebaut. Aber den wollte ich später auch noch nutzen ):
    Aber ich wäre niemals drauf gekommen, dass es daran liegen könnte. Kann man irgendwie einen Typkonverter für float* in diese templateklasse stecken ohne, dass es Probleme gibt?

    0
  • N

    gentoo schrieb:

    Aber ich wäre niemals drauf gekommen, dass es daran liegen könnte. Kann man irgendwie einen Typkonverter für float* in diese templateklasse stecken ohne, dass es Probleme gibt?

    Warum nicht eine einfache Memberfunktion?

    Konvertierungsoperatoren sollten sowieso mit Bedacht eingesetzt werden. Man muss sich bewusst sein, dass es dann wirklich viele Kontexte gibt, wo eine Umwandlung implizit stattfinden kann. Und nicht selten führt das zu Problemen.

    0
  • P

    Lass ihn raus. Wie du siehst zieht der Compiler die Konvertierungen immer mit in Betracht und nicht nur dann wann du sie gerne hättest. Wozu wolltest du sie denn nutzen?

    0
  • G

    ach ich wollte opengl, welches häufig float arrays benutzt mein object einfach so übergeben.

    0
  • D

    gentoo schrieb:

    ach ich wollte opengl, welches häufig float arrays benutzt mein object einfach so übergeben.

    Das geht auch mit normalen Funktionen ganz gut.

    0
Anmelden zum Antworten