#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<3,4> james;
    cout << "Hello world!" << endl;
    return 0;
}

Warum kann ich kein Objekt aus diesem Template erfolgreich erstellen ?

#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<3,4> james;
    cout << "Hello world!" << endl;
    return 0;
}

Sorry so war das gemeint bei main xD
soldat<int,int> james(3,4);

geht aber auch nicht

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?

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)

#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;
}

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;}

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.

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;
}

// ...
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.

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);
}

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

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();

}