1 隐藏（重定义） 

隐藏是指：在基类和派生类中有同名的成员变量或成员函数，那么派生类的成员变量、成员函数就将基类的隐藏（重定义）了。 

 

如何调用隐藏的成员函数（或使用隐藏的成员变量）？ 

 

指定作用域 

 

2 派生类的六个默认成员函数 

在默认情况下，派生类的默认成员函数由基类的成员函数合成（具体实现见下面的代码） 

（1）构造函数 

子类的构造函数，继承了父类的构造函数，需要先调用父类的构造函数，再构造自己的成员。 

对于子类中继承而来的父类的成员，一般可以采用匿名对象的方式进行初始化 

（2）拷贝构造 

对子类的拷贝构造，先将参数t中切片给子类中从父类继承而来的成员，再对子类中自己的成员进行拷贝构造。 

 

（3）赋值运算符重载 

赋值运算符的函数均为operator=，所以明显子类和父类的赋值运算符重载函数的函数名一样，构成隐藏（重定义），在子类中调用父类的赋值运算符重载函数时需要指定作用域。 

（4）析构函数 

一般析构函数不显示的调用。 

虽然子类和父类的函数名不同，但在编译器中会对析构函数进行处理，全部变为函数名为distructor的函数，所以析构函数也构成隐藏（重定义），如果想要调用父类的析构函数，必须指定作用域。 

析构函数是先析构子类自己的成员，再调用父类的析构函数。

//派生类的六个默认成员函数（以日期类为例）
class Date
{
public:
      Date(int year = 1900,int month = 1,int day = 1)
            :_year(year)
            ,_month(month)
            ,_day(day)
      {}
      Date(const Date& d)
            :_year(d._year)
            ,_month(d._month)
            ,_day(d._day)
      {}
      Date& operator=(const Date& d)
      {
            _year = d._year;
            _month = d._month;
            _day = d._day;
            return *this;
      }
      ~Date()
      {}

private:
      int _year;
      int _month;
      int _day;
};
class Time :public Date
{
public:
      Time(int hour = 0, int minute = 0, int second = 0)
            :Date()               //构造函数：子类中从父类继承的成员，采用匿名对象的方式进行构造
            , _hour(hour)
            , _minute(minute)
            , _second(second)
      {}
      Time(const Time& t)
            :Date(t)            //“切片”
            , _hour(t._hour)
            , _minute(t._minute)
            , _second(t._second)
      {}
      Time& operator=(const Time& t) //与父类的operator构成重定义,需要指定Date的作用域调用operator=
      {
            if (this != &t)
            {
                  Date::operator=(t);
                  _hour = t._hour;
                  _minute = t._minute;
                  _second = t._second;
            }
            return *this;
      }
      ~Time()  //与父类的析构函数也构成重定义，需要指定作用域的调用，但是一般都不需要显示的调用
      {
            Date::~Date();
      }

private:
      int _hour;
      int _minute;
      int _second;
};


3 定义一个不能被继承的类 

将构造函数定义为私有的 

a.对于父类中私有的成员，不论在哪种继承方式下对于子类而言都是不可见的； 

b.子类在构造时，必须先调用父类的构造函数，再构造自己的； 

c.不可见的成员是无法调用的，所以该类不能被继承。 

d.有一个需要注意的就是：当我们把构造函数定义为私有的，则不能生成该类的实例 

e.定义一个静态的公有方法，用于生成该类的实例



//定义一个不能被继承的类
class A
{
public:
      static A* GetInstance()
      {
            return new A();
      }
private:
      A()
      {}
};

int main()
{
      A* pa = A::GetInstance();
      return 0;
}

继承
1. 派生类中的默认成员函数
2. 继承与友元、静态成员

1. 派生类中的默认成员函数


6个默认成员函数：构造函数、析构函数、拷贝构造函数、赋值重载、取地址重载（普通对象和const对象取地址）


派生类的构造函数必须调用基类的构造函数初始化基类的那一部分成员，如果基类没有默认的构造函数，则必须在派生类构造函数的初始化列表阶段显式调用；


派生类拷贝构造函数必须调用基类的拷贝构造完成基类的拷贝初始化；


派生类的operator=必须要调用基类的operator=完成基类的复制；


派生类的析构函数会在被调用完成后自动调用基类的析构函数清理基类成员；


派生类对象初始化先调用基类构造再调用派生类构造；


派生类对象析构清理先调用派生类析构，再调用基类的析构。



//成员初始化顺序，一定先初始化父类成员，后初始化子类成员
class Person
{
public:
	//构造函数
	Person(int id=1, int age=16)
		:_id(id)
		, _age(age)
	{
		cout << "Person(int, int)" << endl;
	}

	//无缺省值构造函数
	/*Person(int id, int age)
		:_id(id)
		, _age(age)
	{
		cout << "Person(int, int)" << endl;
	}*/

	//拷贝构造
	Person(const Person& p)
		:_id(p._id)
		,_age(p._age)
	{
		cout << "Person(const Person&)" << endl;
	}

	//赋值运算符重载
	Person& operator=(const Person& p)
	{
		if (this != &p)
		{
			_id = p._id;
			_age = p._age;
		}
		cout << "Person& operator=(const Person& p)" << endl;
		return *this;
	}

	//析构函数
	~Person() {
		cout << "~Person()" << endl;
	}
protected:
	int _id;
	int _age;
};
class Student :public Person
{
public:
	//不能在子类的初始化列表中直接初始化父类的成员
	//如果父类有默认构造，初始化列表可以不用显式调用父类的构造函数，编译器会自动调用父类构造
	//如果父类没有默认构造，必须显式调用父类的一个构造函数
	Student(int id,int age,int stuId)
		:_stuId(stuId)
	{
		//Person(id, age);
		cout << "Student(int, int, int)" << endl;
	}

	//父类无缺省值时
	/*Student(int id, int age, int stuId)
		:Person(id, age)
		, _stuId(stuId)
	{
		cout << "Student(int, int, int)" << endl;
	}*/
	//拷贝构造的初始化列表中可以调用普通的父类构造函数
	//也可以调用拷贝构造
	Student(const Student& stu)
		:Person(stu)
		,_stuId(stu._stuId)
	{
		cout << "Student(const Student&)" << endl;
	}

	Student& operator=(const Student& stu)
	{
		if (this != &stu)
		{
			//父类的赋值和子类的赋值运算符构成同名隐藏，需要加上父类作用域
			Person::operator=(stu);
			//operator=(stu);递归调用自己，同名隐藏，直到栈溢出才停止
			_id = stu._id;
			_age = stu._age;
			_stuId = stu._stuId;
		}
		cout << "Student& operator=(const Student& stu)" << endl;
		return *this;
	}
	//析构
	//编译器在任何情况下，都会自动调用父类的析构，所以不需要显式调用父类析构
	~Student()
	{
		//~Person();子类析构和父类析构构成同名隐藏，析构函数底层的函数名：destruct
		//Person::~Person();
		cout << "~Student()" << endl;
	}	
private:
	int _stuId;
};
void test()
{
	//子类的默认构造会自动调用父类的构造函数
	//先父类后子类
	Student stu(1, 2, 3);
	//子类默认的拷贝构造会自动调用父类的拷贝构造
	//如果子类显式定义了拷贝构造，子类的拷贝构造会自动调用父类的默认构造
	Student copy(stu);
	//赋值：子类的默认赋值运算符会自动调用父类的赋值运算符
	//子类定义的赋值运算符不会自动调用父类的赋值运算符，除非显式调用
	stu = copy;

	//析构：子类默认的析构/显式调用都会自动调用父类的析构
	//先子类后父类
	Student stu1(1, 2, 3);
}

2. 继承与友元、静态成员

友元关系不能继承，基类友元不能访问子类私有的和保护的成员。
基类定义了static静态成员，则整个继承体系中只有一个这样的成员，无论派生多少个子类，都只有一个static成员实例。

//基类的static成员在整个继承体中，被所有对象共享
class A
{
public:
	A()
	{
		++_a;
	}
public:
	static int _a;
};
int A::_a = 0;
class B :public A
{};
class C :public B
{};
void test()
{
	A a;
	B b;
	C c;
	cout << a._a << endl;
	cout << b._a << endl;
	cout << c._a << endl;
	cout << &a._a << endl;
	cout << &b._a << endl;
	cout << &c._a << endl;
}

用派生类B中的成员函数Show()，对基类A中的成员函数Show()进行覆盖。
例子：
#include <iostream>
using namespace std;
class A
{
public:
	void Show() { cout<<"A::Show()"<<endl; }
};
class B : public A
{
public:
	void Show() { cout<<"B::Show()"<<endl; }//在派生类中重新定义成员函数
	void Display() { Show(); }
};

int main()
{
	A a;
	B b;
	a.Show();
	b.Show();
	b.Display();

	return 0;
}


程序运行显示结果：




如果想在派生类B的成员函数Display()中调用基类A的成员函数Show()，可以使用作用域限定符 '::'，如下所示：
void Display() { A::Show(); }  //调用基类A的成员函数SHow()

看下面这个例子：
class A

{

protected:

 A(){}

 ~A(){}

public:

 virtual void print()

 {

  cout<<"A::print()!"<<endl;

 }

};

class B:public A

{

public:

 B(){}

 ~B(){}

private:

 virtual void print()

 {

  cout<<"B::print()!"<<endl;

 }

};

int main()

{

 //A obj;//ERROR

 B d;

 A *pB = &d;

 pB->print();

 return 0;

}
最后输出"B::print()!",调用的是派生类B中的私有成员函数
print是一个虚函数，pB指向都内容是Derived，所以 pB->print() 调用的是Derivied::print()。
至于private的问题，因为pB是指向Base的指针，调用Base的private函数是可以的（只不过Base::print()那个虚函数指针的内容是 Derivied::print())？？？这句话没看懂，实在不知道为什么会这样？？？