class Counter
{
      public:
             Counter();
             ~Counter(){}
             int GetItsVal()const { return itsVal; }
             void SetItsVal(int x) { itsVal = x; }
             const Counter& operator++();           //<-- hier liegt mein Problem
             const Counter operator++(int);

      private:
              int itsVal;
};

in der Kommentierten Zeile wird doch eine Referenz vom Typ "Counter" auf "operator++()" erzeugt, wenn ich mich nciht täusche?
Aber worauf referiert diese? oder habe ich einen Denkfehler?
Bitte um Hilfe.

in der Kommentierten Zeile wird doch eine Referenz vom Typ "Counter" auf "operator++()" erzeugt, wenn ich mich nciht täusche?

Nein, das ist eine Deklaration einer Elementfunktion (aka "Methode"), welche eine Referenz als Rüchgabewert hat.

Wowa705 schrieb:

Aber worauf referiert diese? oder habe ich einen Denkfehler?

Das kann man der Deklaration nicht ansehen. Muss man dort nachgucken, wo die Funktion definiert ist, was da für ein return-Statement steht. Typischerweise würde man hier das const weglassen und die Funktion mit "return *this;" abschließen.

int &rDieRef = einInt;

was soviel bedeutet wie "rDieRef verweist auf einInt und ist vom Typ int" oder?

Wowa705 schrieb:

in der Kommentierten Zeile wird doch eine Referenz vom Typ "Counter" auf "operator++()" erzeugt, wenn ich mich nciht täusche?

Nein, das ist eine Deklaration einer Elementfunktion (aka "Methode"), welche eine Referenz als Rüchgabewert hat.

ok das habe ich soweit verstanden.
Mein Problem liegt nun darin, dass ich mich frage: einerseits habe ich gelern, ich darf Referenzen nicht uninitialisiert lassen. jedoch finde ich die Initialisierung hier nicht(oder ist das der Teil in der Finktionsdefinition?).
Dann verstehe ich jedoch die Syntax nicht ganz.

Die Methodendefinition:

const Counter& Counter::operator++()
{
      ++itsVal;
      return *this;
}

wenn ich nun aber eine Referenz deklariere, schreibe ich doch z.B.

int &rDieRef = einInt;

was soviel bedeutet wie "rDieRef verweist auf einInt und ist vom Typ int" oder?

Nein. Das besagt, dass rDieRef eine Referenz auf ein int ist. rDieRef ist aber vom Typ int& nicht int .

//EDIT
Das return this ist sozusagen die Initialisierung der Referenz.

Wie genau sieht dann die Deklaration(+Initialisierung) einer allgemeinen Methode aus? kann mir das evtl. jemand sagen? das würde mir in meinem Verstöndnis enorm weiter helfen denke ich.

Ich denke was dir am meisten helfen würde wäre ein ordentliches Buch (C++ Primer z.B.)...

Ich denke was dir am meisten helfen würde wäre ein ordentliches Buch (C++ Primer z.B.)...

danke für den äußerst hilfreichen Beitrag. wieso können leute in Foren so oft nich beim thema Bleiben.

an alle anderen: danke für die Beiträge, die waren im gegensatz zu dem eben genannten wirklich hilfreich.

danke für den äußerst hilfreichen Beitrag.

Der Beitrag war total angebracht. Die letzte Frage, die Du gestellt hast, zeigt, dass Dir ganz viel an Basiswissen fehlt, welches Du Dir locker selbstständig erarbeiten könntest. Du wirst sicherlich verstehen, dass es viel einfacher ist, zu sagen "Schnapp Dir ein C++ Buch und lerne" als hier einen langen Aufsatz über C und C++ zu schreiben, der alles beinhaltet, was Du noch nicht verstanden haben könntest.

Wie genau sieht dann die Deklaration(+Initialisierung) einer allgemeinen Methode aus? kann mir das evtl. jemand sagen? das würde mir in meinem Verstöndnis enorm weiter helfen denke ich.

Initialisierung einer Methode? Meinst du eventuell Definition? Mal folgendes zu Deklaration, Definition und Initialisierung:

/* ------ Funktionen ------ */

// Deklaration: sagt dem Compiler das die Funktion existiert
// Definition: sagt dem Compiler was die Funktion tut (Implementierung)

int foo(); // Deklaration

int foo()  // Definition
{ ... }    //

/* ------- Methoden ------- */

// Deklaration: siehe oben
// Definition: siehe oben

class Foo
{
public:
    int bar(); // Deklaration
};

int Foo::bar() // Definition
{ ... }        //

/* ------ Variablen ------- */

// Deklaration: sagt dem Compiler den Namen und den Typ einer Variablen
// Definition: der Compiler reserviert Speicherplatz für die Variable
// Initialisierung: die Variable mit einem Wert belegen

int var1 = 1; // Deklaration, Definition UND Initialisierung

int var2; // Deklaration UND Definition

extern int var3; // Deklaration (Definition wo anders)

struct Foobar {
    static int var3; // Deklaration
};
int Foobar::var3; // Definition

Aber es gibt keine Initialisierung von Funktionen oder Methode.

@krümelkacker:
und nochmals vielen Dank. Ich lerne bereits anhand eines Buches. Da dabei aber hin und wieder Fragen aufkommen, versuche ich mich im Internet schlau zu machen, was bisher auch gut funktionierte. Oder soll ich nun bei jeder Frage, die ich habe in den Laden rennen und mir ein neues Buch darüber kaufen? Und genau solche Leute sind bei der Internetrecherche ziemlich störend, da man erst etliche Beiträge erhält, die nicht auf die Frage antworten, um dann einen zu erhalten, der einem hilft.
Dabei könnte das Leben doch so einfach sein.

btt:
wie man eine Funktion oder Methode deklariert und definiert ist mir bewusst, was mich an diesem Code irritiert ist vielmehr die Tatsache, dass eine Referenz auf eine Variable folgendermaßen aussieht:

int& rEineRef = einInt;

und liest sich als rEineRef ist eine Referenz und "zeigt" auf einInt.
bei der Methodendeklaration hingegen ist die Syntax scheinbar anders.

und nun meine Fragen dazu:
1. ist die Syntax wirklich eine andere oder durchblicke ich nur etwas nicht?
2. wenn sie anders ist: worin unterscheidet sie sich und wie ist die Lesart?

ich hoffe meine Frage wird nun etwas klarer und nachwievor danke für alle hilfreichen Beiträge.

Und nein, die Syntax ist bei Methoden und Variablen NICHT anders!
Überall heißt das "&" Referenz.

#include <iostream>
using namespace std;

struct Test {
    int val;

    Test& self() {  // gibt eine Referenz auf this zurück
        return *this;
    }

    int value() const { // das hier gibt ne Kopie auf val zurück
        return val;
    }
};

int main() {
    Test t;
    t.val = 10;

    Test& rt = t.self();
    rt.val = 15;
    cout << t.val << endl;

    const Test& crt = t.self();
    //crt.val =17;  // gut, das geht nicht, wir haben nur ne const-Referenz

    Test ct = t.self();  // das ist jetzt ne Kopie
    ct.val = 20;
    cout << t.val << endl;   // 15
    cout << ct.val << endl;  // 20

    int x = 10;
    int& rx = x;
    rx = 15;
    cout << x << endl;

    const int& crx = x;
    // crx = 17; // Geht wieder nicht... -> const-Referenz
}

Vielleicht ist es etwas klarer.

Mit welchem Buch arbeitest du denn?

sonst vielen danke an Alle. hat mir sehr geholfen...