Initialisierung, Verhalten definiert?

Pellaeon

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.
Ansonsten kannst nur warten bis die "Standard-CPP-Gurus" was posten

7H3 N4C3R

In der Initialisierungsliste ist das okay und richtig und definiert - wenn auch meiner Meinung nach nicht schön.

Jordy

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.

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

volkard

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.

Jordy

volkard schrieb:

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.

7H3 N4C3R

volkard schrieb:

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.

Konfusius

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

SideWinder

Konfusius schrieb:

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

Hmm, imho gar nix gut.

MfG SideWinder

Jordy

Konfusius schrieb:

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.

7H3 N4C3R

http://www.kuzbass.ru:8086/docs/isocpp/special.html

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.