Wozu dient das?

Wozu dient das eigentlich wenn ich im Konstruktor wert=w schreibe, kann man das auch weglassen??
Also Beispiel:

class beispiel{
  int wert1;
  int wert2;
  beispiel(int wert1,int wert2)
}
beispiel::beispiel(int wert1,int wert2){
  wert1=w1;
  wert2=w2;
}

Muss das so sein, oder kann ich die geschweiften Klammern leer lassen??
Wozu dient diese Doppelbennenung??????

Freu mich auf Antworten

drakon

Also meines Erachtens macht das w1, w2 gar keinen Sinn..

Im übrigen fehlt dir das Semikolon am Ende der Klassen Definition.

BorisDieKlinge

beispiel::beispiel(int wert1,int wert2){
  wert1=w1;
  wert2=w2;
}

stellt den Konstruktor der klasse da. Durch den die Klassenvariablen initialisiert werden.

Damit dieser aber Sinn macht, müsste er so lauten:

beispiel::beispiel(int wert1,int wert2){
  this->wert1=wert1;
  this->wert2=wert2;
}

oder so

beispiel::beispiel(int w1,int w2){
  wert1=w1;
  wert2=w2;
}

Hallo

Am besten man benutzt in solchen Fällen Initialisierungslisten.

chrische

asc

Der Maulwurf schrieb:

Wozu dient das eigentlich wenn ich im Konstruktor wert=w schreibe, kann man das auch weglassen??

Wie schon angegeben ist dein Beispiel schlicht und ergreifend fehlerhaft, ich passe es mal an:

class Beispiel
{
  private:
    int wert1;
    int wert2;
  public:
    Beispiel(int wert1, int wert2);
};

// Entweder (schlechter)
Beispiel::Beispiel(int wert1,int wert2)
{
  this->wert1=wert1;
  this->wert2=wert2;
}
// Oder (besser)
Beispiel::Beispiel(int wert1,int wert2)
: wert1(wert1),
  wert2(wert2)
{
}

Die Zuordnung muss sein, wenn du die übergabe des Konstruktors auch in die Membervariablen übernehmen willst (Und das ist wohl der eigentliche Sinn). Auch wenn die Variablennamen der Membervariablen und der Übergabeparameter identisch sind, so sind sie doch nicht wirklich identisch! (Thema: Scope)

Vielleicht wird das folgende eindeutiger:

int main()
{
  int a = 4;
  {
    int a = 3; // "Überdeckt" äußeres a
    std::cout << a << std::endl;
  } // <-- Inneres a existiert nicht mehr
  std::cout << a << std::endl;
}

Gehen wir nun nochmal das Beispiel an, und kommentieren es mal detailiert aus:

class Beispiel
{
  private:
    int wert1;  // Member wert1 von einer Instanz der Klasse Beispiel
    int wert2;  // Member wert2 von einer Instanz der Klasse Beispiel
  public:
    //       < Arg1  >  <  Arg2 > <-- lokale Variablen (genauer Parameter/Argumente) der Methode!
    Beispiel(int wert1, int wert2);
};

Beispiel::Beispiel(int wert1,int wert2)
{
// < Member > = <lokale Variable>
  this->wert1 = wert1;
  this->wert2 = wert2;
  // Innerhalb der Methode (Hier: Konstruktor), sind wert1 und wert2
  // lokal gültig. Sie überdecken vom Namen her die Member der Klasse,
  // und sind nicht identisch. Um auf die Member der Klasse zugreifen
  // zu können, kann man aber über den Instanzzeiger (this) gehen.
  // Sprich: this->wert1 = wert1 bedeutet das ich den Wert der lokalen
  // Variable wert1 der Membervariable wert1 übergebe
}

// Dies ist Konstruktorschreibweise mit Initialisierungsliste (grundsätzlich
// besser), hierbei wird this nicht explizit angegeben, da in der Initialisierungsliste
// der Wert vor der Klammer implizit ein Member sein muss, die Zuweisung
// [genauer: Konstruktoraufruf] aber bei Namensgleichheit sich aus dem
// Parametern zusammensetzt:
Beispiel::Beispiel(int wert1,int wert2)
: wert1(wert1),
  wert2(wert2)
{
}

cu André