C++继承解析

继承的概念及定义

继承的概念
继承是面向对象程序设计使代码可以重复使用的重要手段，它可以在原有类的基础上进行扩展，增加功能，产生新的类，称为派生类，派生类拥有原有类的所有成员，是一种类的复用的重要思想。

继承的定义
继承定义的格式：

派生类的继承方式和对基类成员访问权限：

总结：
1.基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。
2.基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。
3.根据上面表格所示，基类的私有成员在子类都是不可见。基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符与继承方式中范围最小的那个)，public > protected > private。
4.使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public。

继承和组合
public继承是一种is-a的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a的关系。假设B组合了A，每个B对象中都有一个A对象。

// Car和BMW Car和Benz构成is-a的关系 
class Car
{
protected:
    string _colour = "白色";  // 颜色 
    string _num = "陕ABIT00";    // 车牌号
};

class BMW : public Car
{
public:
    void Drive() {cout << "好开-操控" << endl;}
};

class Benz : public Car
{
public:
    void Drive() {cout << "好坐-舒适" << endl;}
};

// Tire和Car构成has-a的关系 
class Tire
{
protected:
    string _brand = "Michelin";  // 品牌 
    size_t _size = 17;           // 尺寸
};

class Car
{
protected:
    string _colour = "白色";      // 颜色 
    string _num = "陕ABIT00";     // 车牌号 
    Tire _t;                     // 轮胎
};

注：优先使用对象组合，而不是类继承。
原因：
类继承中，一般基类的内部细节对子类可见，会一定程度破坏了基类的封装，基类的改变，对派生类类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合中，因为向的内部细节是不可见的，所以对象组合之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。

基类和派生类对象赋值转换（public继承）

1.子类对象可以赋值给父类对象（切割/切片）
2.父类对象不能赋值给子类对象
3.父类指针/引用可以指向子类对象
4.子类指针/引用不可以指向父类对象

class Person
{
public:
	void Display()
	{
		cout << _name << endl;
	}
protected:
	string _name; // 姓名
};


class Student : public Person
{
public:
	int _num; // 学号
};

int main()
{
	Person p;
	Student s;
	// 1.子类对象可以赋值给父类对象（切割 /切片）
	p = s;
	// 2.父类对象不能赋值给子类对象
	//s = p;
	// 3.父类的指针/引用可以指向子类对象
	Person* p1 = &s;
	Person& r1 = s;
	// 4.子类的指针/引用不能指向父类对象（可以通过强制类型转换完成）
	Student* p2 = (Student*)& p;
	Student& r2 = (Student&)p;
	p2->_num = 10;
	r2._num = 20;
	return 0;
}

继承中的作用域及隐藏

1.在继承体系中基类和派生类都有独立的作用域。
2.子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）
3.需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏。
例子：

class Person
{
public:
	void fun()
	{
		cout << "Person::func()" << endl;
	}
protected:
	string _name = "小李子"; // 姓名 
	int _num = 111;        // 身份证号
};

class Student : public Person
{
public:
	void fun()
	{
		cout << "Student::func()" << endl;
	}
	void Print()
	{
		cout << " 姓名:" << _name << endl;
		cout << " 身份证号:" << Person::_num << endl;
		cout << " 学号:" << _num << endl;
	}
protected:
	int _num = 999; // 学号
};
int main()
{
	Student s1;
	s1.Print();
	s1.fun();
	return 0;
}

结果图：

如上所述：打印身份证号的时候因为_num前面声明了类作用域，所以调用的是父类用的_num，调用func函数的时候，因为没有类访问作用域的声明，所以子类的func函数隐藏了父类中的同名函数，从而调用的是子类的func函数。

重载和隐藏很像，但是他们有区别：
重载：在同一作用域下，函数名相同，参数类型或个数不同。
隐藏：在不同作用域下，函数名相同，参数不用考虑。

派生类的默认成员函数

如果派生类继承了父类且派生类中没有显式定义6个默认成员函数，那么编译器会自动生成。
那么派生类中的默认成员函数是怎么构成的呢？
1.构造函数：先调用父类的构造函数，再调用子类的构造函数。

2.拷贝构造函数：在拷贝一个子类对象时，该子类对象中的父类部分会由父类的拷贝构造来完成（切片/切割）

3.赋值运算符重载：一定要确定作用域！,在赋值过程中，父类部分会调用父类的赋值运算符重载函数，但是，子类的和父类的函数名相同，都是operator=，会构成隐藏，变成子类不停的调用自己的赋值运算符重载函数（父类函数被屏蔽），最终会造成栈溢出！

4.析构函数：先析构子类对象，再析构父类对象（注意！，在写派生类的析构函数时，不用自己调用父类的析构函数，毕竟先析构子类，父类会有操作系统自己来调用）

其实构造和析构函数很好理解：要构造一个子类对象，他的一部分来自父类，所以先构造好父类的那一部分，再构造剩余子类自己的那部分。又因为后构造的先析构（满足栈的特性），所以先析构子类对象那部分，再析构父类对象那部分。

class Person//父类
{
public:
	Person(const char* name)//构造函数
		: _name(name)
	{
		cout << "Person()" << endl;
	}


	Person(const Person& p)//拷贝构造函数
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

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

	~Person()//析构函数
	{
		cout << "~Person()" << endl;
	}

protected:
	string _name; // 姓名
};


class Student : public Person//子类
{
public:

	Student(const char* name, int num)//构造函数，（先调用父类的构造函数，再调用子类的构造函数。）
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)//拷贝构造函数，在拷贝一个子类对象时，该子类对象中的父类部分会由父类的拷贝构造来完成（切片/切割）
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}

	Student& operator = (const Student& s)//赋值运算符重载

	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			Person::operator =(s);//此处一定要确定作用域，原因见上文第3点
			_num = s._num;
		}
		return *this;
	}

	~Student()//析构函数，，先析构子类对象，再析构父类对象
	{
		cout << "~Student()" << endl;//（不用自己调用父类的析构函数）
	}

private:
	int _num; //学号
};



int main()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
	return 0;
}

结果图：

继承与友元

友元关系不能继承，也就是说基类友元不能访问子类私有和保护成员。

class Student;

class Person
{
public:
    friend void Display(const Person& p, const Student& s); protected:
    string _name; // 姓名
};
class Student : public Person
{
protected:
    int _stuNum; // 学号
};

void Display(const Person& p, const Student& s)
{
    cout << p._name << endl; 
    cout << s._stuNum << endl;
}

void main()
{
    Person p; 
    Student s; 
    Display(p, s);
}

继承与静态成员

基类中定义了静态（static）成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例。

class Person
{
public :
    Person () {++ _count ;} protected :
    string _name ; // 姓名
public :
    static int _count; // 统计人的个数。
};
int Person :: _count = 0; 
class Student : public Person
{
protected :
    int _stuNum ; // 学号
};
class Graduate : public Student
{
protected :
    string _seminarCourse ; // 研究科目
};
int main()
{
    Student s1 ; 
    Student s2 ; 
    Student s3 ; 
    Graduate s4 ;
    cout <<" 人数 :"<< Person ::_count << endl; 
    Student ::_count = 0;
    cout <<" 人数 :"<< Person ::_count << endl;
    return 0;
}