Printable View
Hey ppl,
i have a class similar to this one
Which does give me a "illegal member initialization, Foo is not a base or member". What i want to do actually, is to have the specialized constructor Foo(int a), call Foo(void) for common initializations and then have its special variable initialized.Code:class Foo
{
public:
Foo(void) : m1(0) {};
Foo(int a) : Foo(), a(a) {};
~Foo(void) {};
private:
int m1;
int a;
};
How can i get this to work with initializations lists?
Best regard, threahdead
C++ doesn't allow nested constructors. Notice that you should probably initialize a to some value anyway, so you might be able to use a constructor with default parameters:Code:Foo(int a = 0) : a(a), m1(0) { }
This will be only possible in C++0x, which adds "delegating constructors" to the language.
Currently, one overload of a constructor cannot reuse a different constructor of the same class.
-------
BTW, even in C++0x I doubt that you will be allowed to initialize the same member twice (although technically the default constructor just leaves one member uninitialized).
A quote from the draft for C++0x:
The emphasised part says that you will never be able to do exactly what you are asking.Quote:
6 A mem-initializer-list can delegate to another constructor of the constructor’s class using any class-ordecltype
that denotes the constructor’s class itself. If a mem-initializer-id designates the constructor’s class,
it shall be the only mem-initializer; the constructor is a delegating constructor, and the constructor selected
by the mem-initializer is the target constructor. The principal constructor is the first constructor invoked
in the construction of an object (that is, not a target constructor for that object’s construction). The
target constructor is selected by overload resolution. Once the target constructor returns, the body of the
delegating constructor is executed. If a constructor delegates to itself directly or indirectly, the program is
ill-formed; no diagnostic is required. [ Example:
—end example ]Code:struct C {
C( int ) { } // #1: non-delegating constructor
C(): C(42) { } // #2: delegates to #1
C( char c ) : C(42.0) { } // #3: ill-formed due to recursion with #4
C( double d ) : C(’a’) { } // #4: ill-formed due to recursion with #3
};
Thanks for replies. Sadly, in my case default values in the constructor are not an option.
Why not?
As laserlight asked, why not?Quote:
Originally Posted by threahdead
Your example seems rather silly - in fact, dangerous - because the member a is not actually initialised by the default constructor, but it is for an object constructed from an int - with no way for an object to detect the difference. Any member that retrieves the value of an uninitialised "a" will give undefined behaviour.
The solution to use common code in constructors - assuming that is OK from the constructor body - is typically to have a private initialiser function, and call it from each constructor.
BTW, why do people keep calling it 'C++0x'? Shouldn't it be C++1x now? Unless they plan on waiting another 90 years to release it? :D
The next version of the C++ standard is currently scheduled to be C++0B :)Quote:
Originally Posted by cpjust
Because that's how my compiler calls it, it doesn't accept "-std=c++1x".
You are absolutely correct about my example. In my code, which i was too lazy to type in here, it is a little bit different. Let me give you a better example.Quote:
Originally Posted by grumpy
I have a whole bunch of variables which are initialized to the same values in all specialized constructors and only one or two which are initialized to special values in each constructor respectively.
What i want to do is still the same, have a constructor with no arguments that initializes m1, m2 and m3 which can be called from the initialization list in each of the specialized constructors.Code:class Foo
{
public:
Foo(A a) : m1(0), m2(0), m3(0), a(a), b(NULL) {};
Foo(B b) : m1(0), m2(0), m3(0), b(b), a(NULL) {};
~Foo() {};
private:
int m1, m2, m3;
A a;
B b;
};
Which would be much cleaner code.Code:Foo(void) : m1(0), m2(0), m3(0) {};
Foo(A a) : Foo(), a(a), b(NULL) {};
Best regards, threahdead
Well one workaround would be to use inheritance to do that. You can call the base-class constructor which would initialize the m variables, and then let the inherited class take care of the specialized constructors. It is the only way you can do what you want that i know of.
I understand that's what you want to do. If your compiler complies with the original C++ standard, you can't. In future you will be able to do that with delegating constructors (assuming that feature is ratified, which seems likely).
You might try putting the m1, m2, m3 members into a helper class (or struct) that has a default constructor to initialise them. It's not as clean as you might like, but does allow reuse of the initialisation logic.
Also, for readability sake, it's often considered a good idea to avoid giving arguments of constructors the same name as a member of the class. Having a(a) in an initialiser list is an easy way to confuse yourself - or some poor sucker maintaining your code in future.
Or using default initializers in the class definition! Handy stuff!Quote:
Originally Posted by grumpy
Yeah, but that's not what was asked for.Quote:
Originally Posted by Elysia
That is exactly what was asked for:
So, in other words, default initialize all of the variables in the class body, and have the constructors initialize the specific variables to specific values.Quote:
Originally Posted by threahdead
Except that the example provided (in which the default constructor initialised ints and pointers to particular values) was not along the lines of what was asked for.