Kann C++ das? (template problem)



  • Sagen wir Ich habe eine Klasse X

    template <typename schweineschwarte>
    class X
    {
    public:
       X();
       ~X();
    private:
      schweineschwarte myValue;
    };
    

    Aus welchem Grund auch immer möchte ich verschiedene Konstruktoren für einige vordefinierte Datentypen.

    Kann C++ so etwas?

    Etwa so:

    const int magic_number_seven = 7;
    const float magic_number_fifteen_point_two_two_eight_float = 15.228f;
    
    X<int>::X()
    : myValue(magic_number_seven)
    {
    }
    
    X<float>::X()
    : myValue(magic_number_fifteen_point_two_two_eight_float)
    {
    }
    
    //Zusätzlich noch den "Standard"-Konstruktor
    x<schweineschwarte>::X()
    {
       myValue = schweineschwarte();
    }
    

    Kann C++ so etwas?



  • TravisG schrieb:

    Aus welchem Grund auch immer möchte ich verschiedene Konstruktoren für einige vordefinierte Datentypen.

    Templatespezialisierung wäre eine Möglichkeit. Auch wenn ich ganz und gar kein Freund von Magicnumbers bin...

    template<typename T>
    class A{/**/};
    
    template<>
    class A<long>{/**/}; //<-- Spezialisierung für long...
    


  • Wie ich dich verstehe, willst du partielle Spezialisierung von Memberfunktionen, was in C++ leider nicht möglich ist.
    Da musst du den Umweg über die partielle Spezialisierung des gesamten Templates gehen.



  • drakon schrieb:

    Wie ich dich verstehe, willst du partielle Spezialisierung von Memberfunktionen, was in C++ leider nicht möglich ist.
    Da musst du den Umweg über die partielle Spezialisierung des gesamten Templates gehen.

    Wieso partiell?



  • Nexus schrieb:

    drakon schrieb:

    Wie ich dich verstehe, willst du partielle Spezialisierung von Memberfunktionen, was in C++ leider nicht möglich ist.
    Da musst du den Umweg über die partielle Spezialisierung des gesamten Templates gehen.

    Wieso partiell?

    Huch. 🙂
    Gehen tuts trotzdem noch nicht. Auche eine volle Spezialisierung ist nicht möglich. 🙂



  • schade.



  • TravisG schrieb:

    schade.

    die code verdopplung die durch komplette spezialisierung der klasse entsteht kann man natuerlich durch kleine initialisierungsklassen/funktionen umgehen.

    erklär deshalb mal was du genau erreichen willst - dann finden wir einen weg.



  • Man kann sehr gut, wie Shade schon andeutete, die Initialisierung in ein eigenes Template auslagern und das dann zur Initialisierung spezialisieren. Um mal das gefragte Beispiel entsprechend anzupassen:

    template<typename schweineschwarte>
    struct XInitHelper; // forward, s.u.
    
    template<typename schweineschwarte>
    X<schweineschwarte>::X()
    : myValue(XInitHelper<schweineschwarte>::value())
    {
    }
    
    const int magic_number_seven = 7;
    const float magic_number_fifteen_point_two_two_eight_float = 15.228f;
    
    template<typename schweineschwarte>
    struct XInitHelper
    {
        static schweineschwarte value() { return schweineschwarte(); }
    };
    
    template<>
    struct XInitHelper<int>
    {
        static int value() { return magic_number_seven; }
    }; 
    
    // etc...
    

Anmelden zum Antworten