Re: Copy constructors
keith@bytebrothers.co.uk wrote in
news:1192723042.495675.186110@e34g2000pro.googlegroups.com:
On 18 Oct, 16:37, Joe Greer <jgr...@doubletake.com> wrote:
ke...@bytebrothers.co.uk wrote in news:1192721104.884316.307060
@k35g2000prh.googlegroups.com:
OK, this makes the warning go away - thanks. Now, what's
happening? I thought that by the time we reached Derived's
constructor (in this case, copy constructor), Base was guaranteed
to have been fully constructed. This result implies I am wrong...
Don't read too much into the syntax. This basically just tells the
compiler which constructor to use for the base class and provides the
opportunity to provide parameters to the base class' constructor. By
the time your Derived member initialization occurs and your
constructor body is executed, the base class will have been
initialized.
Ahhh... My understanding was _nearly_ correct; By the time we reach
Derived's constructor's BODY, Base is guaranteed to have been fully
constructed. But while we are still in the initialisation list, we
can (and apparently should) explicitly call Base's constructor.
Have I got it right now?!
You can picture it like that as long as you realize that the base class
(es) constructors will get called in the order they are declared in the
class and not in any arbitrary order, then the member initialization(s)
for your derived class will occur, and then the body of the constructor
will be invoked. Remember that you can have multiple inheritance, so
you may have more than one base class constructor to specify.
So, for example:
#include <iostream>
#include <string>
class Base {
int m_i;
public:
Base(int i) : m_i(i) {std::cout << "Base" << std::endl;}
};
class Base1 {
int m_i;
public:
Base1(int i) : m_i(i) {std::cout << "Base1" << std::endl;}
};
class Item1 {
public:
Item1() { std::cout << "Item1" << std::endl;}
};
class Item2 {
public:
Item2() { std::cout << "Item2" << std::endl;}
};
class Derived : public Base1, public Base {
Item1 m_Item1;
Item2 m_Item2;
public:
Derived(int i) : Base(i), Base1(i), m_Item2(), m_Item1() {std::cout
<< "Derived" << std::endl;}
};
int main()
{
Derived d(5);
}
The output of this program is:
Base1
Base
Item1
Item2
Derived
As you can see, the bases are initialized in the order declared in the
class definition, not in the order they appear in the constructor list
and the items are initialized in the order they appear in the class, not
in the order of the list, but all of the items in the list are done
before the body of the constructor is executed.
Hope that helps,
joe