二十五、继承(二) 不能自动继承的成员函数、继承与构造函数、友元关系与继承、静态成员与继承

一、不能自动继承的成员函数
          有三种函数不能被继承，构造函数，析构函数和=运算符，基类的构造函数和析构函数只负责对基类数据成员的初始化和清理，因为基类并不知道派生类有哪些数据成员。=运算符和构造函数功能类似，所以也不能被继承。
二、继承与构造函数

          基类的构造函数不被继承，所以派生类中需要声明自己的构造函数来初始化新增的数据成员。在声明构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化（调用基类构造函数完成）。为了在派生类中调用基类构造函数，派生类的构造函数需要给基类的构造函数传递参数。在构造派生类的时候，先调用基类的构造函数，在调用派生类的对象函数。
例子：

#include <iostream>
using namespace std;
class ObjectB
{
public:
ObjectB(int objb) : objb_(objb)
{
cout<<"ObjectB ..."<<endl;
}
~ObjectB()
{
cout<<"~ObjectB ..."<<endl;
}
int objb_;
};

class ObjectD
{
public:
ObjectD(int objd) : objd_(objd)
{
cout<<"ObjectD ..."<<endl;
}
~ObjectD()
{
cout<<"~ObjectD ..."<<endl;
}
int objd_;
};

class Base
{
public:
Base(int b) : b_(b), objb_(111)
{
cout<<"Base ..."<<endl;
}
Base(const Base& other) : objb_(other.objb_), b_(other.b_)
{

}
~Base()
{
cout<<"~Base ..."<<endl;
}
int b_;
//对象组合
ObjectB objb_;
};

class Derived : public Base
{
public:
Derived(int b, int d) : d_(d), Base(b), objd_(222)
{
cout<<"Derived ..."<<endl;
}
Derived(const Derived& other) : d_(other.d_), objd_(other.objd_), Base(other)
{

}
~Derived()
{
cout<<"~Derived ..."<<endl;
}
int d_;
ObjectD objd_;
};

int main(void)
{
Derived d(100, 200);
cout<<d.b_<<" "<<d.d_<<endl;

Base b1(100);
Base b2(b1);
cout<<b2.b_<<endl;

Derived d2(d);
return 0;
}

运行结果：



内存对象模型：



三、友元关系与继承
          友元关系不能被继承。友元关系是单向的，是不能传递的，也是不能被继承的。
四、静态成员与继承

          静态成无所谓继承。静态成员在内存中的静态存储区，对于类的静态变量来说，即使类没有实例也可以访问其静态变量。如果有实例的话，那么静态变量被所有实例共享。对于基类包含静态成员的派生类来说，基类和派生类共享一块内存，也就是说，基类和派生类共享一个静态变量。

#include <iostream>
using namespace std;
class Base
{
public:
Base(int t) :b(t){}
static void show()
{
cout<<"Base show"<<endl;
}
static int a;
int b;
};
int Base::a = 99;
class Derived : public Base
{
public:
Derived(int t):Base(t){}
static void show()
{
cout<<"Derived show"<<endl;
}
};
int main(void)
{
Base base(10);
Derived d(200);
cout<<"static Base::a="<<Base::a<<endl;
cout<<"non static Base::b="<<base.b<<endl;
cout<<"static Derived::a="<<Derived::a<<endl;
cout<<"non static Derived::b="<<d.b<<endl;
d.show();
//d.Base::show();
return 0;
}

结果：




五、需要在初始化列表初始化的情况总结

const成员和引用成员(因为两者都需要在定义的时候初始化，对于类成员来说，初始化只能在构造函数中)
基类的构造(没有默认构造函数的情况下)和组合对象成员(没有默认构造函数的情况下)

          对象的构造先调用基类对象成员构造函数，然后调用基类构造函数，接着调用派生类对象成员的构造函数，最后调用派生类的构造函数。析构的顺序和构造正好相反。如果类包含多个对象成员，那么对象成员的构造顺序是和声明顺序相同的。