3. Template

Template

  • N

    Verzweiflung schrieb:

    hustbaer schrieb:

    guck mal wie viele template parameter dein klassen-template soldat hat
    und dann guck wie viele du angibst
    und dann lies dir nochmal die regeln bezüglich non-const lvalue referenzen und rvalues durch

    Sind das nicht einfach nur Gehalt und Stufe?

    Wieviele verschiedene Templateparameter? (Das sind die Dinger zwischen template < und > class)

    0
  • V

    Leuder ist völlig unklar, was Du suchst.

    #include <iostream>

using namespace std;

template <typename T,typename U>class soldat{
private:
    T gehalt;
    U stufe;
public:

    soldat(T a, U b){ gehalt = a; stufe = b;}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat<int,float> james(3,2.71);
    cout << "Hello world!" << '\n';
    return 0;
}

    #include <iostream>

using namespace std;

template <typename T>class soldat{
private:
    T gehalt;
    T stufe;
public:

    soldat(T a, T b){ gehalt = a; stufe = b;}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat<int> james(3,4);
    cout << "Hello world!" << '\n';
    return 0;
}

    #include <iostream>

using namespace std;

class soldat{
private:
    int gehalt;
    int stufe;
public:

    soldat(int a, int b){ gehalt = a; stufe = b;}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat james(3,4);
    cout << "Hello world!" << '\n';
    return 0;
}

    #include <iostream>

using namespace std;

template<int gehalt>
class soldat{
private:
    int stufe;
public:

    soldat(int b){stufe = b;}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat<3> james(4);
    cout << "Hello world!" << '\n';
    return 0;
}

    #include <iostream>

using namespace std;

template<int gehalt,int stufe>
class soldat{
private:
public:

    soldat(){}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat<3,4> james();//löl
    cout << "Hello world!" << '\n';
    return 0;
}

    #include <iostream>

using namespace std;

template<typename U,typename V,U gehalt,V stufe>
class soldat{
private:
public:
    soldat(){}
    ~soldat(){};

    void getSoldat(){cout << gehalt << " "  << stufe;};
};

int main()
{
    soldat<int,long,3,4> james;
    cout << "Hello world!" << '\n';
    return 0;
}
    0
  • Mod

    hustbaer schrieb:

    und dann lies dir nochmal die regeln bezüglich non-const lvalue referenzen und rvalues durch

    Was hustbaer damit meint:

    soldat(T &a, T &b){ gehalt = a; stufe = b;}

    Dass a und b Referenzen sind, ist hier überflüssig. Da sie nicht verändert werden, reicht auch einfach call by value (ohne Ampersand) - falls man aber sicherstellen möchte, dass keine Kopie angelegt wird, macht man eine Const-Referenz (oder wie auch immer Nexus das geschrieben haben will :D):

    soldat(T const& a, T const& b){ gehalt = a; stufe = b;}
    0
  • N

    Arcoth schrieb:

    Const-Referenz (oder wie auch immer Nexus das geschrieben haben will :D)

    Richtig so 😉

    Wobei die Hauptsache ist, dass man nicht von "konstanter Referenz" spricht.

    0
  • ?

    Danke für die vielen guten Post.
    Hat mir schonmal sehr geholfen 👍

    Muss jetzt nur noch bisschen Praxis rein bekommen damit ich den Kram glaube ich wirklich verstehe und inhaliert habe 😃

    Aber eine kleine Frage habe ich noch auch, wenn die sicher google bar wäre

    #include <iostream>

using namespace std;

template <class T> class soldat{
    private:
        int gehalt;
        int rang;
    public:

    soldat(T &a,T &b){gehalt=a;rang=b;}; // Warum funktionieren hier keine Referenzen oO
    soldat(){};

    void get_lesen(){cout << gehalt << " " << rang;};
};

int main()
{
    soldat<int> james(3,4);
    cout << "Hello world!" << '\n';
    return 0;
}
    0
  • N

    Weil du nur LValues (grob: adressierbare Objekte) an Referenzen binden kannst. 3 ist ein Literal und als solches kein Objekt mit einer assoziierten Adresse im Speicher. Worauf sollte also die Referenz zeigen?

    0
  • D

    Verzweiflung schrieb:

    // ...
template <class T> class soldat{
    private:
        T gehalt;
        T rang;
// ...
};

    Wenn schon Template, dann verwende es auch bitte. Sonst kannst du dein Template auch ganz streichen.

    0
  • ?

    Dank euch komme ich deutlich besser jetzt mit Templates klar hab aber leider wieder ne Frage. Ich versuche gerade warum auch immer eine Template Klasse in eine Template Klasse einzubauen. Ich gehe mal einfach davon aus das es möglich ist 🙄 Ka ob man sowas überhaupt braucht aber naja man lebt nur einmal 😋

    template<class T> class mt{
public:
    void get_test(){cout << "Test";};

    template <class A, class B> double addieren(A a, B b){
        return a+b;
    }

    template<class X> class kana{
        private:
                X affe;
        public:
                kana(X a){affe = a;};
                ~kana(){};
                void get_test2(){cout << "KANA";};
    };

};

int main(){

int erster=1;
double zweiter = 2.2;

 mt<void> hund; // ich bin mir schon bewusst das templates mit void prima sein müssen xD
 hund.get_test();
 cout << " " << hund.addieren(2,3) << " " << hund.addieren(erster,zweiter);
 hund.kana<int> lili(3);
}
    0
  • ?

    Das geht schon, aber Subklassen musst du über ihre vollen Klassennamen ansprechen, soll heißen:

    mt<void>::kana<int> lili(3);
    0
  • ?

    Eine letzte Frage noch versprochen 🙂
    Ohne was dafür groß zutun also gar nicht erstellt sich der Konstruktor von Kana schonmal. Also müsste ich die Klasse in meiner Klasse doch über hund ansprechen können in main was als Objekt für die Klasse mt erstellt wurde oder?

    Ausgabe:

    MT Konstruktor
    Test 5 3.2
    KANA KONSTRUKTOR

    Super schonmal das sich die Kana Klasse selber schonmal erstellt wie ich die auch immer, dann ansprechen soll ohne Name xD.

    #include <iostream>
using namespace std;

template<class T> class mt{
public:
    mt(){cout << endl << "MT Konstruktor " << endl;}; // HIER DER KONSTRUKTOR

    void get_test(){cout << "Test";};

    template <class A, class B> double addieren(A a, B b){
        return a+b;
    }

    template<class X> class kana{
        private:
                X affe;
        public:
                kana(X a=3){affe = a; cout << endl << "KANA KONSTRUKTOR" << endl;};
                ~kana(){};
                void get_test2(){cout << "KANA";};
    };

};

int main(){
int erster=1;
double zweiter = 2.2;

 mt<void> hund;
 hund.get_test();
 cout << " " << hund.addieren(2,3) << " " << hund.addieren(erster,zweiter);
 mt<void>::kana<int> lili(3);

 lili.get_test2();

}
    0
  • D

    Klassen in Klassen sind in C++ immer statisch. D.h. hund hat kein kana -Objekt.
    Du kannst hund allerdings ein solches Objekt geben, indem du in hund einen mt<T>::kana<int> -Objekt gibst. Das würde den Template-character allerdings wieder völlig zerstören... (Da du einen Datentyp vorgeben musst)

    0
Anmelden zum Antworten