继承（二）

1.不能继承的成员函数

   （1）构造函数

   （2）析构函数

   （3）=运算符

2.继承与构造函数

   （1）基类的构造函数不被继承，派生类需要声明自己的构造函数。

   （2）声明构造函数时，只需要对本类中新增成员进行初始化，对继承来的基类成员的初始化（调用基类构造函数完成）。

   （3）派生类的构造函数需要给基类的构造函数传递参数。

   （4）派生类对象的构造次序：

              [1]调用基类的对象成员的构造函数

              [2]调用基类构造函数

              [3]派生类的对象成员的构造函数

              [4]派生类自身的构造函数

    （5）需要初始化列表初始化：

              [1]const成员

              [2]引用成员

              [3]类的对象成员没有默认构造函数的时候，只能够在类的构造函数初始化列表中，调用该对象的构造函数初始化。

              [4]基类没有默认的构造函数的时候，基类的构造函数要在派生类构造函数初始化列表中调用。

#include <iostream>

using namespace std;


class ObjectB {
public:
	ObjectB(int objb):objb_(objb) {
		cout << "ObjectB ..." << endl;
	}
	/*ObjectB(const ObjectB& other) {
	}*/
	~ObjectB() {
		cout << "~ObjectB ..." << endl;
	}
public:
	int objb_;
};
class ObjectD {
public:
	ObjectD(int objd):objd_(objd) {
		cout << "ObjectD ..." << endl;
	}
	~ObjectD() {
		cout << "~ObjectD ..." << endl;
	}
public:
	int objd_;
};

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

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


int main(void) {
	Derived d(1, 2, 3, 4);
	cout << d.b_ << " " << d.objb_.objb_ << " " << d.d_ << " " << d.objd_.objd_ << endl;
	
	cout << "---------------------" << endl;
	Base b1(100, 200);
	Base b2(b1);
	cout << b2.b_ << " " << b2.objb_.objb_ << endl;
	
	Derived d2(d);
	cout << d2.b_ << " " << d2.objb_.objb_ << " " << d2.d_ << " " << d2.objd_.objd_ << endl;
	return 0;
}

3.友元关系与继承

   （1）友元关系不能被继承

   （2）友元关系是单向的

   （3）友元关系是不能被传递的

4.静态成员与继承

    （1）静态成员无所谓继承

#include <iostream>
using namespace std;


class Base {
public:
        static int s_;
};

int Base::s_ = 100;

class Derived: public Base {
public:
};




int main(void) {
        Base b;
        cout << Base::s_ << endl;
        cout << b.s_ << endl;

        Derived d;
        cout << Derived::s_ << endl;
        cout << d.s_ << endl;


        return 0;
}