Anforderung an Template Parameter



  • Hallo,
    mal eine kurze Frage .

    Ich habe gelesen, dass bei Funktions-Templates der verwendete Typ des Parameters einen Kopierkonstruktor, Zuweisungsoperator und öffentlichen Destruktor besitzen sollte, damit es fehlerfrei ausgeprägt werden kann.

    Bei elementaren Typen, wie Int, Double usw. ist das doch nicht nötig oder, lediglich bei Klassen oder?

    Danke



  • @Lou-Cyphr3 sagte in Anforderung an Template Parameter:

    Ich habe gelesen, dass bei Funktions-Templates der verwendete Typ des Parameters einen Kopierkonstruktor, Zuweisungsoperator und öffentlichen Destruktor besitzen sollte, damit es fehlerfrei ausgeprägt werden kann.

    Warum?



  • @manni66

    weil dann angeblich nicht übersetzt wird. warum das so sein soll? naja vllt wenn der erstellte Typ im Template zugewiesen wird und dem Compiler vllt nicht ganz klar ist, welchen konstruktor er aufrufen soll, bzw, wie er zuweisen soll?



  • @Lou-Cyphr3 sagte in Anforderung an Template Parameter:

    @manni66

    weil dann angeblich nicht übersetzt wird.

    Das hängt von der Art des Templates ab, die Notwendigkeit besteht nur dann, wenn diese Funktionalität auch explizit benutzt wird. Wenn man etwa ein function template mit Referenzen schreibt, dann wird nichts davon im Template benötigt.



  • Zuweisungsoperator ist nicht nötig, wüsste nicht wozu.
    Kopierkonstruktor sowie Destruktor sind auch nur nötig wenn du einfach T im Template schreibst. Du kannst aber auch sowas wie T const& schreiben.

    #include <stdlib.h>
    #include <new>
    
    struct Foo {
        Foo(Foo const&) = delete;
        Foo& operator =(Foo const&) = delete;
        ~Foo() = delete;
    
        Foo(int, int, int);
    
        void fooIt() const;
    };
    
    template <class T>
    void tpl(T const& t) {
        t.fooIt();
    }
    
    void pfeifft() {
        void* mem = malloc(sizeof(Foo)); // Sollte man normal nicht so machen, 
        Foo* f = new(mem) Foo(1, 2, 3);  // nur zur Veranschaulichung dass zum Aufruf der Template-Funktion nichtmal ein Destruktor nötig ist
        tpl(*f);
        free(mem);
    }
    

    Und genaugenommen muss der Typ nichtmal kopierbar sein wenn du nur T schreibst:

    struct Foo2 {
        Foo2(int, int, int);
        Foo2& operator =(Foo2 const&) = delete;
    
        void fooIt() const;
    };
    
    template <class T>
    void tpl2(T t) {
        t.fooIt();
    }
    
    Foo2 makeFoo2() {
        return {1, 2, 3};
    }
    
    void pfeifftGenauso() {
        tpl2<Foo2>({1, 2, 3});
        tpl2(makeFoo2());
    }
    


  • @Lou-Cyphr3
    Es geht darum:

    template <class T>
    void tpl(T t) {
        // ...
    }
    
    void fun() {
        MeinTyp mt;
        tpl(mt);
    }
    

    Hier wird T als MeinTyp hergeleitet. Die Funktion hat also einen Parameter vom Typ MeinTyp. Die Variable ist auch vom Typ MeinTyp. Bei der Parameterübergabe muss aber der Wert kopiert werden. Also braucht MeinTyp einen Kopierkonstruktor (bzw. genauer: muss kopierbar sein). Weiters muss der Parameter beim Verlassen der Funktion wieder zerstört werden. Also muss MeinTyp einen Destruktor haben (bzw. genauer: muss zerstörbar sein). Integers haben zwar weder einen Kopierkonstruktor noch Destruktor, aber sie sind kopierbar und zerstörbar.

    Wofür ein Zuweisungsoperator nötig sein soll, weiss ich nicht.


Log in to reply