C++类的继承与函数模板

类的继承

概念

继承(inheritance)机制是使得函数功能可以复用的重要手段，它允许程序在保持原有类的基础上增加功能，产生新的类，新的类被称为子类或者派生类，被继承的类被称为父类或者是基类。类的继承体现了C++区别于C的面向对象编程的特点。

例如，人类是一个基类，包括人具有的一些属性，例如，年龄、性别或工作等，那么，学生类和教师类就是人类的派生类或子类，可能具有一些人类不具有的属性，例如，学号或者教师编号等。

#include<iostream>
#include<string>
using namespace std;
class Person//人类
{
	public:
		void Print();
	private:
		string m_name = "peter";
		int m_age = 18;
};
//人类具有名字等人类共有的属性
void Person::Print()
{
	cout << "name:" << m_name << endl;
	cout << "age:" << m_age << endl;
}

class Student : public Person
{
	private:
		long int student_id = 1220019046;
	public:
    	void S_print();
};
//学生类继承人类，继承方式是公用继承，学生类具有人类不具有的属性：学号。
void Student::S_print()
{
    cout << "The student_id is " << student_id << endl;
}

int main()
{
	Student s;
	s.Print();//s也可以调用人类的成员函数。
    s.S_print();//s可以调用学生类的成员函数。
	return 0;
}

定义

使用格式

class 子类名:继承方式 父类名
{
	private:
	public:
	protected:
};

继承方式

继承方式分为三种，分别是public继承、protected继承和private继承。不同的继承方式对于子类访问父类的的成员权限设置不同：public继承子类访问权限最高、protected继承次之、private继承对父类成员的访问权限最低。

总结

 无论子类以什么方式继承父类，父类的private成员在子类中均不可见(子类不可访问)。不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

如果在上述代码示例中，学生类(子类)以protected继承的方式继承人类(父类)，那么代码运行将出现bug。

因为Student s是在main函数中调用的父类的protected成员，而在上面的表格中，子类如果以protected继承方式继承父类，父类中的protected成员将成为派生类的protected成员，而protected成员是不允许在类外被访问的。所以在main函数(类外)中调用protected成员是不被允许的。

函数模板

概念

//函数模板
#include<iostream>
using namespace std;

void swapInt(int &a, int &b)//引用传递
{
    int temp = a;
    a = b;
    b = temp;
}

void swapDouble(double &a, double &b)
{
    double temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;
    swapInt(a, b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    double c = 30.54;
    double d = 40.32;
    swapDouble(c, d);
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
}

int main()
{
    test01();
    return 0;
}

上述代码中的两个函数实现了同样的功能——交换两个变量的值，两个函数唯一的区别就是接收参数的类型不同，swapInt函数接收整型变量而swapDouble函数接受双精度浮点型变量，但两个函数的功能是一样的。功能一样的函数却要在程序中重复写两遍，这无疑增加了程序的冗杂度并且造成了程序的低可读性。所以需要一个函数模板能够化繁为简。这无疑又体现了C++的强大。

定义

函数模板代表了一类函数，实现某些特定的功能，在使用时被特殊化。

函数模板格式

template<typename T1, typename T2, ... ,typename Tn>
返回值类型 函数名(参数列表)
{
    //...
}

template是定义函数模板的关键字，后面跟的是尖括号<>。

typename是定义模板参数的关键字。

T1, T2, ..., Tn表示的是函数名。(T更像是变量名关键字，在使用时具体化后会被其他变量类型例如int、float、double等替换)

因此，两个交换变量的值的函数就可以套用函数模板：

//函数模板
#include<iostream>
using namespace std;

// void swapInt(int &a, int &b)//引用传递
// {
//     int temp = a;
//     a = b;
//     b = temp;
// }

// void swapDouble(double &a, double &b)
// {
//     double temp = a;
//     a = b;
//     b = temp;
// }

template<typename T>
T exchange(T &x, T &y)
{
    T temp = x;
    x = y;
    y = temp;
    return (x, y);
}

void test01()
{
    int a = 10;
    int b = 20;
    exchange(a, b);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;

    double c = 30.54;
    double d = 40.32;
    exchange(c, d);
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
}

int main()
{
    test01();
    return 0;
}

注意："函数模板不是一个实在的函数，编译器不能为其生成可执行代码。定义函数模板后只是一个对函数功能框架的描述，当它具体执行时，将根据传递的实际参数决定其功能。"  —— 《百度百科》

在上述代码中调用了两次exchange函数，但是exchange函数的实参类型是不一样的，编译器在编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。

函数模板与具体函数调用原则

1、一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数

以下代码编译器会调用哪个函数？

##include<iostream>
using namespace std;
int Add(int left, int right)
{
    cout << "当然是直接用现成的了" << endl;
	return left + right;
}
template<typename T>
T Add(T left, T right)
{
    cout << "left + right = " << left+right << endl;
	return left + right;
}
int main()
{
    int a = 3;
    int b = 4;
	Add(a, b); //会调用哪个Add函数？
}

 模板函数不仅没实现参数相加的功能，还被编译器具体化成了已有的函数功能——在终端上打印字符串

当然，也可以使用特定的方法强制让编译器调用函数模板

#include<iostream>
using namespace std;
int Add(int left, int right)
{
    cout << "当然是直接用现成的了" << endl;
	return left + right;
}
template<typename T>
T Add(T left, T right)
{
    cout << "left + right = " << left+right << endl;
	return left + right;
}
int main()
{
    int a = 3;
    int b = 4;
	Add<int>(a, b); //会调用哪个Add函数？
}

 2、对于非模板函数和同名函数模板，如果其他条件都相同，在调动时会优先调用非模板函数而不会从该模板产生出一个实例。如果模板可以产生一个具有更好匹配的函数， 那么将选择模板

编译器是非常聪明的，就像使用内联函数时，编译器会根据自己判断决定要不要使用内联函数，而不会仅凭程序员的编写。

#include<iostream>
using namespace std;
int Add(int left, int right)
{
	return left + right;
}
template<typename T1, typename T2>
T1 Add(T1 left, T2 right)
{
	return left + right;
}
int main()
{
	cout << "Add(1, 2) = " << Add(1, 2) << endl; // 与非函数模板类型完全匹配，不需要函数模板实例化
	cout << "Add(1, 2.0) = " << Add(1, 2.0) << endl; // 模板函数可以生成更加匹配的版本，编译器根据实参生成更加匹配的Add函数
    return 0;
}