Template Klasse mit Konvertierungsoperator Problem

Folgendes simples Beispiel veranschaulicht mein Problem:

template <typename T>
class Wert
{
    private:
        T wert;
    public:
        Wert(const T w);
        operator T&(){return wert;}
};

In der main Funktion steht:

Wert<float> g(9.81f);
float v = g;

Beim Kompilieren bekomme ich einen "undefined symbol" error, der eindeutig mit dem überladenen Operator zusammenhängt. Die Wert Klasse ist nur ein simpler Wrapper für eine normale Variable, deshalb möchte ich sie auch intuitiv nutzen können, so wie in der letzten Zeile.

Wie mach ich das richtig?

Con*n

Hi,

Du hast bei Deinem Konstuktor die geschweiften Klammer weggelassen.

grüße Con@n

Das ist vollkommen Wurst die in Implementation des Konstruktors ist egal.

Sorry, aber dein Code funktioniert!!!!!!!!1

Visual C++ 7.1

kacke, dann liegt's wohl am Codewarrior oder meinen Compilereinstellungen hmm.

#include <iostream>
#include <conio.h>

template<class T> 
class Wert 
{ 
  private: 
    T wert; 
  public: 
    Wert(const T& w){}; 
    operator T&(){ return wert; } 
};

int main()
{
    Wert<float> g(9.81); 
    std::cout << g;
    getch();
}

Die geschweiften Klammern nach dem Konstruktor müssen sein.
Ansonsten: undefined reference to 'Wert<float>::Wert(float const&)'
Als Ausgabe erfolgt: 6.12429e-039 (???)

Unter GCC bekomm ich auch eine undefined reference hmm, also wie geht es richtig?

int main()
{
    Wert<double> g(9.81); 
    std::cout << g;
    getch();
}

ergibt: 2.07906e-307
Kann das bitte jemand erklären?

int main()
{
    Wert<int> g(9); 
    std::cout << g;
    getch();
}

ergibt: 4370436

#include <iostream>
#include <conio.h>

template<class T> class Wert 
{ 
  private: 
    T wert; 
  public: 
    Wert(const T& w){wert = w;}; // hier muss etwas in wert übergeben werden.
    operator T&(){ return wert; } 
};

int main()
{
    Wert<float> g(9.81f); 
    std::cout << g;
    getch();
}

wieso sorgt das operator T&(){ return wert; } dafür, dass der Operator << für cout funktioniert?

#include <iostream>
#include <conio.h>

template<class T> class Wert 
{ 
  private: 
    T wert; 
  public: 
    Wert(const T& w):wert(w){}; // Init-Liste
    operator T&(){ return wert; } 
};

Bolero Tiger schrieb:

int main()
{
    Wert<double> g(9.81); 
    std::cout << g;
    getch();
}
ergibt: 2.07906e-307
Kann das bitte jemand erklären?
int main()
{
    Wert<int> g(9); 
    std::cout << g;
    getch();
}
ergibt: 4370436

Da g nicht initialisiert worden ist, enthält es zufällige Werte. Den Konstruktor habe ich wegen der Einfachheit weggelassen, daß er wert initialisiert ist ja logo.

.. dein Code kompiliert bei mir auch, hat wohl was damit zu tun, wie ich die Template Klassenimplementierung in einen Header schreibe.

scheiße es geeeeeeht!! Ich bin ja ein Deppchef, dabei war's nur wieder ein dummer Fehler von mir.

Okay, noch was anderes, folgendes funktioniert:

Wert<float> a(10.0f);
a = a/2.0f;

folgendes aber nicht:
a /= 2.0f;

Frage: Wieso und was kann man dagegen tun?

Wozu ist das Ganze eigentlich gut?