1. Beispiel:
IntList(const IntList& list); //Konstruktor der Klasse IntList
void append(const int& x);
void prepend(const int& x);

wird zu ==>

List(const List<T>& list);
void append(const T& x);
void prepend(const T& x);

also int -> T

2. Beispiel

bool Contains(int aElem);
void Delete(int aElem);
void Insert(int aElem);

wird zu ==>

bool Contains(T& aElem);
void Delete(T& aElem);
void Insert(T& aElem);

also int -> T&

Und das verwirrt mich, wann muss der datentyp zu T und wann zu T& verändert werden?

Danke schonmal im voraus.

Anstatt diesen T&'s gehören überall const T&'s hin,

Würde ich auch sagen

anstatt den int's const int's

Top-Level const in Parametertypen ist egal.
Verändert nichtmal die Signatur.
Anders gesagt, es ist OK eine Funktion z.B. mit

void foo(int param);

zu deklarieren und dann mit

void foo(int const param)
{
}

zu definieren.

Was sich ändert ist lediglich ob man den Parameter innerhalb der Definition von foo ändern kann oder nicht. Spielt aber für den Aufrufer keine Rolle.

also int -> T&

Und das verwirrt mich, wann muss der datentyp zu T und wann zu T& verändert werden?

Wie schon erwähnt wurde macht T& keinen grossen Sinn, wenn dann T const& (bzw. const T& was aber nur ne andere Schreibweise ist).

Der Unterschied ist dass einmal kopiert wird ( int , T ), und einmal nicht ( int const& , T const& ).

Bei einem Integer ist es egal, bzw. ist es sogar besser ihn zu kopieren, da eine Referenz auf einen Integer meistens langsamer ist als ihn direkt zu kopieren.

Bei beliebigen Datentypen ist es aber meist besser eine Referenz zu übergeben, denn bei Typen wie z.B. std::string ist das Kopieren sicher langsamer als der (vergleichsweise kleine) Overhead den die Referenz verursacht.

Das ganze ist allerdings nicht nur bei Templates relevant. Man sollte auch bei ganz normalen Funktionen die z.B. Strings als Parameter nehmen diese als Referenz-auf-const übergeben (also std::string const& param statt einfach nur std::string param ). Wo es auch oft vergessen wird sind Smart-Pointer, z.B. std::shared_ptr<T> . Die sind zwar hübsch klein, aber trotzdem vergleichsweise sehr langsam zu kopieren (-> die atomaren Instruktionen die dazu nötig sind sind auf den allermeisten Systemen richtig teuer).

Ich dachte man kann an die Funktion mit int keine const ints übergeben?

Doch, bei Kopien konnte man schon immer CV-Qualizierer entfernen. Wieso auch nicht, const soll ja nur verhindern, dass ein Objekt (und nicht Kopien davon) verändert werden.

Okay, das ist selbst mir neu.

*kicher*

314159265358979 schrieb:

Okay, das ist selbst mir neu.

*kicher*

Was willst du damit ausdrücken? Entweder habe ich es nicht bewusst wahrgenommen, oder eben noch nicht verwendet. Ich denke eher das erstere.

hustbaer schrieb:

314159265358979 schrieb:

Okay, das ist selbst mir neu.

*kicher*

Was willst du damit ausdrücken?

Das dir so einiges nicht bekannt ist.

Die Formulierung impliziert nämlich, dass es sehr erstaunlich ist, dass es dir neu ist. Und diese Implikation fand ich einfach zum kichern.
Streiche das "selbst" aus dem Satz, und er ist vollkommen OK.
(Tip: das "selbst" bedeutet in der Konstellation "sogar", nicht "selbst" im Sinn von "ich selbst")

Ich denke, mit deinen 15 Jahren solltest du dann keine Sätze wie "das ist selbst mir neu" schreiben.

Die Formulierung impliziert nämlich, dass es sehr erstaunlich ist, dass es dir neu ist. Und diese Implikation fand ich einfach zum kichern.
Streiche das "selbst" aus dem Satz, und er ist vollkommen OK.
(Tip: das "selbst" bedeutet in der Konstellation "sogar", nicht "selbst" im Sinn von "ich selbst")

Ich denke, das war selbst ihm neu.