Zahlen()          //Name der Klasse
{
  x = 0;
  y = 0;
}

Aber jetzt steht in dem Buch das Beispiel zu einem zweiten Konstruktor(der zum Einsatz kommt, fall ich Get- bzw. Set-Elemente benutze):

Zahlen(double x_wert, double y_wert)
{
  x = x_wert;
  y = y_wert;
}

Laut meinen bisherigen Erkentnissen kann man einen Konstruktor doch nur ohne Argumente aufrufen!?
und ich will ja nich jedesmal dem Konstruktor Argumente mitteilen(da könnte ich die Variablen ja gleich von Hand definieren)...
Wenn ihr versucht dass mir zu erklären, dann bitte probieren so einfach wie möglich zu schreiben.
EDIT:
Thx für die Antworten

Wenn deine Klasse beide Konstruktoren hat kannst du sowohl als auch aufrufen:

Zahlen xyz; // ruft den standard c'tor auf
Zahlen xyz( 10.0, 20.0 ); // ruft den überladenen c'tor auf

grüße

Sieh dir zum Beispiel mal das an:

class CInteger {
public:
    CInteger(void);                    // Das ist der Standard-Konstruktor
    CInteger(int iNumber);             // Hier wird dem Konstruktor noch ein Wert zur Initialisierung mit auf den Weg gegeben
    CInteger(const CInteger& iOther);  // Und das ist ein Kopierkonstruktor. Den brauchst du, wenn du den Zuweisungsoperator (=) überlädst.
    virtual ~CInteger(void); // Und das ist jetzt der Destruktor. Das virtual kannst du auch weglassen, aber wenn du mal mit Vererbung und so anfängst, kommt es gut, wenn du schon vorher virtual verwendet hat.
    CInteger& operator= (const CInteger& iOther); // Hier wird der Zuweisungsoperator überladen
    CInteger& operator= (int iOther); // und hier nochmal, damit man auch normale ints verwenden kann.
    operator int (void) const; // Dieser Operator wird intern aufgerufen, wenn man im Programm schreibt (int)Variable. Es ist also ein Casting-Operator.
protected:
    int m_iValue; // Und in dieser Membervariable wird der Wert gespeichert.
};

Jetzt schau dir noch die Implementation an:

CInteger::CInteger(void) {
    m_iValue = 0; // Hier bekommt m_iValue als Standard den Wert 0
}

CInteger::CInteger(int iNumber) {
    m_iValue = iNumber; // Hier bekommt m_iValue den Wert iNumber
}

CInteger::CInteger(const CInteger& iOther) {
    m_iValue = iOther.m_iValue; // Hier übernimmt m_iValue den Wert eines anderen Objekts vom Typ CInteger
}

CInteger::~CInteger(void) {
    // Hier brauchen wir nichts zu machen, da wir keinen Speicher dynamisch reserviert haben.
}

CInteger& CInteger::operator= (const CInteger& iOther) {
    // Hier passiert folgendes:
    // CInteger var1, var2;
    // var1 = var2;
    // Intern sieht das aber so aus:
    // var1.operator=(var2);
    m_iValue = iOther.m_iValue;
    return *this;
}

CInteger& CInteger::operator= (int iOther) {
    // Hier passiert fast das selbe wie oben:
    // CInteger var1;
    // int var2;
    // var1 = var2;
    // Intern sieht das wieder so aus:
    // var1.operator=(var2);
    m_iValue = iOther;
    return *this;
}

CInteger::operator int (void) const {
    return m_iValue;
}

Jetzt schau dir noch an, wie man das nutzt:

int main(int argc, char** argv) {
    CInteger var1; // Hier wird CInteger::CInteger(void); aufgerufen.
    CInteger var2(256); // Hier wird CInteger::CInteger(int iNumber); aufgerufen.
    CInteger var3(var1); // Hier wird CInteger::CInteger(const CInteger& iOther); aufgerufen.
    var1 = 256; // Hier wird CInteger& CInteger::operator= (int iOther); aufgerufen
    var1 = var2; // Hier wird CInteger& CInteger::operator= (const CInteger& iOther); aufgerufen.
    int var4;
    var4 = (int)var1; // Hier wird CInteger::operator int (void) const; aufgerufen.
    return 0;
}

und das Verwenden der Initialisierungsliste im Konstruktor ist auch vorteilhaft

Zahlen(double x_wert, double y_wert) 
  : x(x_wert), y(y_wert)
{
}

bis bald
akari