Weiß jemand ob das Verhalten von C++ für den folgenden Code definiert ist?:

class Foo
{
   int bar;

public:
   Foo(int bar) : bar(bar) {}
};

Ich bin mir bewußt, daß man leicht Klarheit schaffen kann, in dem man parameter und member unterschiedlich benennt:

class Foo
{
   int bar;

public:
   Foo(int _bar) : bar(_bar) {}
};

aber ich wüßte doch gerne ob das nur der leserlichkeit dient oder tatsächlich zwingend notwendig ist.

Danke!

Compiler nehmen, Konsolenprogramm schreiben und mit dem Debugger nachschauen

Sowas habe ich mir abgewöhnt, seit dem ich weiß, daß in solchen Details oft jeder Compiler was anderes macht. Selbst wenn ein Compiler das nicht nur compiliert, sondern sogar das richtige tut, heißt das noch lange nicht daß das auch andere machen. Darum die Frage, ob das offiziell definiert ist.

ich habs net nachgelesen, aber alles was nach dem Doppelpunkt ist ist eine Initialierung der Membervariablen einer Klasse. Da man Parameter nicht initialisieren kann ist also eindeutig, was welches bar ist, würde ich zumindest denken.

Ja, genau so habe ich mir das auch gedacht. Andererseits benötigt man für so einen Schluß schon ein wenig Intelligenz. Und die traue ich Compilern nicht unbedingt zu. Außerdem habe ich noch nie eine Initialisierung dieser Form gesehen, sondern immer nur Fälle, in denen der Name des Konstruktorparameters abgewandelt wurde (das aber in vielen lustigen Varianten).

Pellaeon schrieb:

Ansonsten kannst nur warten bis die "Standard-CPP-Gurus" was posten

Jau

ich habs net nachgelesen, aber alles was nach dem Doppelpunkt ist ist eine Initialierung der Membervariablen einer Klasse. Da man Parameter nicht initialisieren kann ist also eindeutig, was welches bar ist, würde ich zumindest denken.

widerspricht aber dem gesetz, den oder möglichst nicht zu verwirren.

struct Bar{
   Bar(int*);
   Bar(Bar*);
};
struct Foo{
   Bar bar;
   Baz baz;
   Foo(int baz):baz(&baz),bar(&baz){
   }
};

was passiert wann und warum?
ich wünsch mir einen dummen und verläßlichen compiler. der schlaue verwickelt sich nur schrecklich in widersprüche.

Pellaeon schrieb:

ich habs net nachgelesen, aber alles was nach dem Doppelpunkt ist ist eine Initialierung der Membervariablen einer Klasse. Da man Parameter nicht initialisieren kann ist also eindeutig, was welches bar ist, würde ich zumindest denken.

widerspricht aber dem gesetz, den oder möglichst nicht zu verwirren.

struct Bar{
   Bar(int*);
   Bar(Bar*);
};
struct Foo{
   Bar bar;
   Baz baz;
   Foo(int baz):baz(&baz),bar(&baz){
   }
};

was passiert wann und warum?
ich wünsch mir einen dummen und verläßlichen compiler. der schlaue verwickelt sich nur schrecklich in widersprüche.

Ähm. Damit hast du aber eigentlich keine Antwort gegeben, oder?

Trotzdem deinem gesteigerten Beispiel wäre durchaus denkbar, daß der Compiler den Unterschied zwischen Parameter und Member begreift.

struct Bar{
   Bar(int*);
   Bar(Bar*);
};
struct Foo{
   Bar bar;
   Baz baz;
   Foo(int baz):baz(&baz),bar(&baz){
   }
};

was passiert wann und warum?

Zuerst wird bar initialisiert mit der Adresse von einem temporär übergebenen int namens baz aus der Parameterliste. Dann stellen wir fest, dass es garkein Baz gibt gibt und hören auf. Wäre Baz ein Bar dann initialisieren wir baz mit der Adresse des temporären ints namens baz aus der Parameterliste.

ich schreibe objekt-variablen immer groß und lokale variablen immer klein. da bleibt mir sowas erspart

Hmm, imho gar nix gut.

MfG SideWinder

ich schreibe objekt-variablen immer groß und lokale variablen immer klein. da bleibt mir sowas erspart

Klar, wie gesagt, es gibt genug Möglichkeiten das über Namensgebung zu umgehen.

Aber was C++ in so einem Fall machen sollte, wissen wir aber immernocn nicht. Die Experten sind sich offenbar nicht einig.

C++ Standard 12.6.2 clause 7

Names in the expression-list of a mem-initializer are evaluated in the scope of the constructor for which the mem-initializer is specified. [Example:

class X {
int a;
int b;
int i;
int j;
public:
const int& r;
X(int i): r(a), b(i), i(i), j(this->i) {}
};

initializes X::r to refer to X::a, initializes X::b with the value of the constructor parameter i, initializes X::i with the value of the constructor parameter i, and initializes X::j with the value of ]X::i; this takes place each time an object of class X is created. ] [Note: because the mem-initializer are evaluated in the scope of the constructor, the this pointer can be used in the expression-list of a mem-initializer to refer to the object being initialized. ]

Also:

class Foo
{
   int bar;

public:
   Foo(int bar) : bar(bar) {}
};

ist definiert.