Code:
class Punkt {
private:
    int x,y;
    int *ptr_x;
    int *ptr_y;
public:
     Punkt (int x, int y);
     void move(int dx, int dy);
};

Punkt::Punkt(int x, int y)
{
    x = x;
    y = y;
    ptr_x = &x;
    ptr_y = &y;
       cout << "Start ptr_x: " << *ptr_x << endl;

void  Punkt::move(int dx, int dy)
{
  cout << "Anzeige: " << *ptr_x << endl;
}

Warum zeigt der Pointer in der Funktion einen komplett anderen Wert an?
Wie lässt sich das lösen?

anscheinend, versteht er das nicht x=x;

class Punkt {
private:
    int xx,yy;
    int *ptr_x;
    int *ptr_y;
public:
     Punkt (int x, int y);
     void move(int dx, int dy);
};

wenn man den rest demnentsprechend ändert funzt das ganze.

ich dachte ich sei verhext

class A
{
  int x_, y_;
// ...
};

In der Initialisierungsliste kann der Compiler das übrigens auflösen, aber danach wirds schwer.

this->x = x;

.

oder du schreibst

this->x = x;

.

wow, cool! Funzt!

Normalerweise hat man bei privaten Membervariablen irgendein pre-/postfix.

class A
{
  int x_, y_;
// ...
};

In der Initialisierungsliste kann der Compiler das übrigens auflösen, aber danach wirds schwer.

Gibt es nicht die Regel, dass Variabeln, die mit '_' beginnen oder enden fuer den Compiler reserviert sind? Oder habe ich das gerade falsch im Kopf?

Gibt es nicht die Regel, dass Variabeln, die mit '_' beginnen oder enden fuer den Compiler reserviert sind? Oder habe ich das gerade falsch im Kopf?

n3242 17.6.4.3.2 Global names schrieb:

Certain sets of names and function signatures are always reserved to the implementation:
— Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter (2.12) is reserved to the implementation for any use.
— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

Deswegen enden die Namen da ja auch mit einem _.

icarus2 schrieb:

Gibt es nicht die Regel, dass Variabeln, die mit '_' beginnen oder enden fuer den Compiler reserviert sind? Oder habe ich das gerade falsch im Kopf?

n3242 17.6.4.3.2 Global names schrieb:

Certain sets of names and function signatures are always reserved to the implementation:
— Each name that contains a double underscore _ _ or begins with an underscore followed by an uppercase letter (2.12) is reserved to the implementation for any use.
— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

Deswegen enden die Namen da ja auch mit einem _.

Diese Regel sollte ich mir nun langsam aber sich einmal merken
Ich vergesse immer, dass Namen, die mit '_' enden nicht reserviert sind.
Danke.

— Each name that begins with an underscore is reserved to the implementation for use as a name in the global namespace.

Da Membervariablen nicht global sind, dürfen diese sogar mit einem Unterstrich anfangen - vorausgesetzt, das zweite Zeichen ist kein weiterer Unterstrich oder Großbuchstabe.

class c_
{
  int v_;
  int v__;
  float v___;
  string v____;
};

Unterstriche sind toll. Ich würde folgendes vorschlagen.

class c_
{
  int v_;
  int v__;
  float v___;
  string v____;
};

Hui, wäre heute der 1.April, könnte man glatt meinen, das sei ein Scherz...

void foo()
{
    std::scoped_lock _(mtx);
}

Unterstriche sind toll. Ich würde folgendes vorschlagen.

class c_
{
  int v_;
  int v__; // meep
  float v___; // meep
  string v____; // meep
};

Each name that contains a double underscore _ _ [...] is reserved to the implementation for any use.

Normalerweise hat man bei privaten Membervariablen irgendein pre-/postfix.

Kannst du erklären, was du unter "normalerweise" verstehst und die Behauptung dann belegen? Es gibt vermutlich ähnlich viele Style-Guides, die Prä-/Postfixe propagieren, wie es auch Style-Guides gibt, die derart schmückendes Beiwerk verabscheuen, weil es die Lesbarkeit herabsetzt.