c++多重继承 和 初始化列表

#include<iostream>
using namespace std;
class human
{
public:
human(int);
virtual ~human(){cout<<"析构人类"<<endl;}
virtual int walk(){return itwalk;}
virtual void setwalk(int w){itwalk=w;}
private:
int itwalk;
};
human::human(int a):itwalk(a)
{
     cout<<"人类的构造函数"<<endl;
}
class father:public human
{
public:
father(int walk,int swit);
virtual ~father(){cout<<"析构父亲"<<endl;}
virtual int getwit(){return itswit;}
     virtual int walk(){return itwalk;}
virtual void setwalk(int w){itwalk=w;}
private:
int itwalk;
int itswit;
};
father::father(int walk,int swit):human(walk),itwalk(walk),itswit(swit)
{

cout<<"创建父亲"<<endl;


}


class mother:public human
{
public:
mother(bool sex,int walk);
virtual ~mother(){cout<<"析构母亲"<<endl;}
virtual bool sex()const{return itsex;}
virtual void setsex(bool sex){itsex=sex;}
protected:
bool itsex;


};


mother::mother(bool sex,int walk):human(walk),itsex(sex)
{
           cout<<"构造母亲"<<endl;
}
class son:public father,public mother
{
public:
void beautiful()const{cout<<"儿子也很帅\n"<<endl;}
son(bool sex,int walk,int swit);
~son(){cout<<"析构儿子"<<endl;}
        virtual int getwit(){return itswit;}
        virtual bool sex()const{return itsex;}
        virtual int walk(){return itwalk;}
        virtual void setsex(bool sex){itsex=sex;}
private:
int itswit;
    int itwalk;
bool itsex;
};
son::son(bool sex,int walk,int swit):father(walk,swit),mother(sex,walk)//,itsex(sex),itswit(swit),itwalk(walk)
{
     cout<<"构造儿子\n"<<endl;
 itswit=sex;
itwalk=walk;
itsex=swit;
}
int main()
{
son *ps=new son(true,50,80);


  cout<<ps->walk()<<endl;
  ps->father::setwalk(80);
  cout<<ps->father::walk()<<endl;
  cout<<ps->walk()<<endl;
delete ps;
return 0;

}

1.子类继承父类后  子类的数据成员分析：

假定A类 有成员   a,b,c

B类有成员 a,b,c 

class C：public A,public B 

{

C(int x,int y,int z);

   int a,b,c;

}；

那么  C类里面有成员 A::a,b,c   B::a,b,c  C::a,b,c

}

于是 初始化列表为  C(int x,int y,int z):A(x,y,z),B(x,y,z),a(x)，b(y),c(z){}

也可以写成C(int x,int y,int z):A(x,y,z),B(x,y,z)

{

     a=x；b=y；c=z；

}

下面就是这回事

son::son(bool sex,int walk,int swit):father(walk,swit),mother(sex,walk)//,itsex(sex),itswit(swit),itwalk(walk)
{
     cout<<"构造儿子\n"<<endl;
  itswit=sex;
 itwalk=walk;
 itsex=swit;
}

C++初始化成员列表：

1. 简述

    主要的场合有四类：初始化对象成员，初始化基类的成员，初始化const成员，初始化引用成员。对于const成员和引用成员，比较简单，这两种变量都要求初始化后不能赋值，因此，只能在成员初始化列表中进行初始化，其他地方不行。本文主要介绍初始化对象成员和初始化基类成员这两种情况。  

2. 初始化对象成员

    具体分为两种情况：第一，该对象具有“无参数的构造函数”，使用初始化成员列表，有可能提升性能；第二，该对象只有“有参数的构造函数”，这种情况，必须使用初始化成员列表。   

#include  < iostream >
using   namespace  std;

class  AK_Zero_Parameter {  //  只有默认的无参数构造函数 
}; 
class  AK_One_Parameter {
   int  m_value;
public :
  AK_One_Parameter( int  value) {  //  只有一个有参数构造函数 
    m_value  =  value;
  } 
};
class  Guns {
  AK_Zero_Parameter ak_1;
  AK_One_Parameter ak_2;
public :
   //  ak_1的构造函数，ak_2的构造函数
  Guns( int  value):ak_2(value){}  
   //  ak_1的构造函数，ak_2的拷贝构造函数 
  Guns(AK_One_Parameter ak_one):ak_2(ak_one) {}
   //  ak_1的构造函数，ak_2的构造函数，ak_2的赋值函数 
// Guns(AK_One_Parameter ak_one):ak_2(0) {  ak_2 = ak_one; }
};
int  main() { 
   system( " PAUSE " ); 
    return   0 ;
}

    其实，Guns的构造过程，首先是构造函数内部调用之前，参考初始化列表，对成员进行初始化工作。顺序根据成员声明的顺序。
    首先，初始化ak_1，ak_1没有在列表中被指定，所以调用了ak_1的“无参数的构造函数”。
    然后，初始化ak_2，ak_2在列表中指定，调用对应的“有参数的构造函数”，如果ak_2也在列表中不指定的话，就必须调用ak_2的“无参数的构造函数”，编译器会在AK_One_Parameter这个类中去寻找，然后会发现找不到“无参数构造函数”，因此会编译失败。
    这里对于ak_1只调用了一次构造函数，并不存在效率提升。效率的提升体现在第二个构造函数与第三个构造函数。
    第二个构造函数，对于ak_2调用了一次拷贝构造函数。
    第三个构造函数，对于ak_2首先调用一次构造函数，然后在构造函数内部，调用了一次赋值函数。

3. 初始化基类的成员

class  Gold_AK: AK_Zero_Parameter,AK_One_Parameter {
public :

  // 初始化基类AK_Zero_Parameter，初始化基类AK_One_Parameter   
  Gold_AK( int  value):AK_One_Parameter(value) {};
}; 

    在上面的代码中，加入上面的代码。对于子类Gold_AK，其构造过程如下：
    首先，初始化基类AK_Zero_Parameter，由于在初始化列表中，没有任何指示，所以调用其“无参数的构造函数”。
    然后，初始化基类AK_One_Parameter，由于在初始化列表中，给出了明确指示，所以调用其“有参数的构造函数”。如果不在列表中给出指示的话，就会试图调用其无参数的构造函数，而其没有这样的函数，编译失败。所以，当基类只有“有参数的构造函数时”子类的构造函数中，必须使用成员初始化列表对齐进行指定。

４. 总结

    初始化对象成员和初始化基类成员，当只有“有参数的构造函数时”，必须在初始化成员列表中进行指示。其余情况，不是必须的，但是有时候，能够提升性能。
    此外，const成员和引用成员的初始化工作，必须在初始化成员列表中指示。
    初始化的顺序与列表无关，与变量声明的顺序有关，基类子类的顺序有关。