Ich möchte einer statischen Variablen einen bistimmten initialwert zuweisen, je nachdem welcher Typ gewählt wurde:

template <class T, const int N>
class tcon
{
    static T RANGE;
};

template<class T, const int N>
T tcon<T,N>::RANGE = 0;

//Das will ich, geht aber nicht!  :rage: 
template<const int N>
float tcon<float, N>::RANGE = 1.234;

Der Compiler klagt:

tcon.h:13: Fehler: invalid use of undefined type »class ns::tcon<float, N>«
tcon.h:3: Fehler: declaration of »class ns::tcon<float, N>«

Ist das überhaupt möglich? Ich muss doch nun nicht die ganze Klasse dafür spezialisieren oder?!?!

Ein großes Dankeschön wieder im Vorraus

//Edit: warum nur funktioniert folgendes (kann ich nur leider überhaupt nicht gebrauchen :

template<>
float tcon<float, 293>::RANGE = 1.234;

du müsstest die partielle spezialisierung AFAIK für die komplette Klasse machen.
partielle SPezialisierung nur von Membern ist leider nicht drin

Hmm. Oder das N weglassen..

template <class T>
class tcon
{
    static T RANGE;
};

template<class T>
T tcon<T>::RANGE = 0;

template<>
float tcon<float>::RANGE = 1.234f;

Ich krieg gerade nur nicht raus, warum es mit dem zweiten Template Parameter nicht geht..

Ich krieg gerade nur nicht raus, warum es mit dem zweiten Template Parameter nicht geht..

Weil das "N weglassen" genau wie das allerletzte beispiel von Pigeon eine vollständige Spezialisierung ist, im gegensatz zur Partiellen SPezialisierung, wo N immernoch offen ist. Zumindets ist das meine Vermutung

Wie mache ich das am geschicktesten?! Die Klasse erben? Wie weise ich dann aber nur den Wert zu?!

template<class T, const int N>
struct base
{
    static T value;
};   

template<const int N>
struct deri : public base<float, N>
{
    static float value; // Das kann ich doch nicht einfach "überladen", da ja dann value 2x existiert, oder? 
};

template <class T, class N>
class tcon
{
    static T RANGE;
};

template<class T,class N>
T tcon<T,N>::RANGE = 0;

template<class N>
class tcon<float,N>{
	static float RANGE;
};

template<class N>
float tcon<float,N>::RANGE = 1.234f;

Spezialisier doch einfach die ganze Klasse..

template <class T, class N>
class tcon
{
    static T RANGE;
};

template<class T,class N>
T tcon<T,N>::RANGE = 0;

template<class N>
class tcon<float,N>{
	static float RANGE;
};

template<class N>
float tcon<float,N>::RANGE = 1.234f;

Dann muss ich sämtliche methoden und variablen von tcon in die tcon<float,N> kopieren oder?

Wie ich das gerade sehe. Ja, sofern sie abhängig vom Template Paramter sind. Die anderen kannst du gut in einer Basisklasse haben und dann davon ableiten.

Jetzt sitz ich völlig auf der Leitung! Wie kann ich denn da ableiten?!

template <class T, class N>
class tcon
{
    static T RANGE;

public:
    void sort();
};

template<class T,class N>
T tcon<T,N>::RANGE = 0;

template<class N>
class tcon<float,N> : public tcon<float,N> //? Der Compiler streikt da ....
{
    static float RANGE;
};

template<class N>
float tcon<float,N>::RANGE = 1.234f;

int main()
{
    tcon<float,23> t;
    t.sort();
}

//Edit: Es ist so gut wie alles float T abhängig!

template<class T,class N>
class tconhelper
{
    protected:
        static T RANGE;
};

template<class T,class N>
T tconhelper<T,N>::RANGE = 0;

template<class N>
struct tconhelper<float,N>
{
    static float RANGE;
};

template<class N>
float tconhelper<float,N>::RANGE = 1.234f;

template<class T,class N>
class tcon:public tconhelper<T,N>
{
    typedef tconhelper<T,N> Helper;
    void test()
    {
        Helper::RANGE=3;//das ist der Preis den man hier zahlen muss ;)
    }
};

//Edit: Es ist so gut wie alles float T abhängig!

Im übrigen solltest du dir nochmal Gedanken machen. Wenn eh alles praktisch alles float ist. Warum dann ein template?! Da reicht doch eine normale Klasse.

//Edit: Es ist so gut wie alles float T abhängig!

Im übrigen solltest du dir nochmal Gedanken machen. Wenn eh alles praktisch alles float ist. Warum dann ein template?! Da reicht doch eine normale Klasse.

Nicht von float, ich meinte T. Nochmal ganz konkret:

template<class T, const int N>
class tcon
{
     T reichtum;
     T schoenheit;

     static T RANGE;  :rolling_eyes: 

public:
     void beherrscheWelt();
     void gehZuBett();
     T sinnDesLebens();
};

template<class T, const int N>
T tcon<T,N>::RANGE = 0;

Ich möchte nun das alles völlig identisch ist wenn ich für T float wähle bis auf die Tatsache, dass der Initialwert der statischen Variable nicht 0 sondern 1,234 ist Jedoch unabhängig von N

Ich spüre die Lösung kommen!

Vielleicht wäre es hier angebracht das N als Ctor Parameter zu nehmen, jenachdem was du damit überhaupt genau vor hast ...