从零开始学编程---C++篇（5）

第五天 C++提高编程

本阶段主要针对C++泛型编程 和 STL 技术做详细讲解，探讨C++更深层的使用

1.模板

1.1 模板的概念

模板就是建立通用的模具，大大提高复用性

模板的特点：

• 模板不可以直接使用，它只是一个框架
• 模板的通用并不是万能的

1.2 函数模板

• C++另一种编程思想称为 ==泛型编程== ，主要利用的技术就是模板
• C++提供两种模板机制:函数模板和类模板

1.2.1 函数模板语法

函数模板作用：

建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表

语法：

template<typename T>
函数声明或定义

解释：

template ---声明创建模板

tapename--- 表明其后面的符号是一种数据类型，可以用class代替

T ---通用的数据类型，名称可以替换，通常为大写字母

示例：

//交换两个数的值通过函数来实现
#include<iostream>
using namespace std;
void swapInt(int& a, int& b)//整形类型数据的交换
{
  int tem = a;
  a = b;
  b = tem;

}
void swapDouble(double& a, double& b)//双精度浮点数的交换
{
  double tem = a;
  a = b;
  b = tem;
}
void test()
{
  int a = 3, b = 4;
  swapInt(a, b);
  cout << "a=" << a << "  " << "b=" << b << endl;
  double a1 = 3.14, b1 = 5.20;
  swapDouble(a1, b1);
  cout << "a1=" << a1 << "  " << "b1=" << b1 << endl;
}
int main()
{
  test();
  system("pause");
  return 0;
}

//交换两个数的值通过模板来实现
#include<iostream>
using namespace std;
template<typename T>
void mySwap(T& a, T& b)
{
  T temp = a;
  a = b;
  b = temp;
}
void test()
{
  int a = 3, b = 4;
  mySwap(a, b);//自动类型推导
  cout << "a=" << a << "  " << "b=" << b << endl;
  double a1 = 3.14, b1 = 5.20;
  mySwap<double>(a1, b1);//显示指定类型
  cout << "a1=" << a1 << "  " << "b1=" << b1 << endl;
}
int main()
{
  test();
  system("pause");
  return 0;
}

总结：

• 函数模板利用关键字 template
• 使用函数模板有两种方式：自动类型推导、显示指定类型
• 模板的目的是为了提高复用性，将类型参数化

1.2.2 函数模板注意事项

注意事项：

• 自动类型推导，必须推导出一致的数据类型T,才可以使用
• 模板必须要确定出T的数据类型，才可以使用

示例：

#include<iostream>
using namespace std;
template<typename T>
void mySwap(T& a, T& b)
{
  T temp = a;
  a = b;
  b = temp;
}
void test01()
{
  int a = 2;
  int b = 3;
  char c = 'c';
  mySwap(a, b);//可以执行，因为可以推导出数据类型
  cout << "a= " << a << "   " << "b= " << b << endl;
  mySwap(a, c);//不可执行，因为a，c数据类型不一致，推导不出相同的数据类型

}

int main()
{
  test01();
  system("pause");
  return 0;
}

#include<iostream>
using namespace std;
template<typename T>
void func()
{
  cout << "调用func函数" << endl;
}
void test01()
{
  
  func();//模板不能独立使用，必须确定出T的类型
  
  func<int>();//利用显示指定类型的方式，给T一个类型，才可以使用模板
}

int main()
{
  test01();
  system("pause");
  return 0;
}

总结：

• 使用模板时必须确定出通用数据类型T，并且能够推导出一致的类型

1.2.3 函数模板案例

案例描述：

• 利用函数模板封装一个排序的函数，可以对不同数据类型数组进行排序
• 排序规则从大到小，排序算法为选择排序
• 分别利用char数组和int数组进行测试

#include<iostream>
using namespace std;
//交换函数模板
template<typename T>
void mySwap(T &a, T&b)
{
  T temp = a;
  a = b;
  b = temp;
}
//选择排序的模板实现
template<class T>
void mySort(T arr[], int len)
{
  for (int i = 0; i < len; i++)
  {
    int max = i;
    for (int j = i + 1; j < len; j++)
    {
      if (arr[max] < arr[j])
      {
        max = j;
      }
    }
    if (max!=i)
    {
      mySwap(arr[max], arr[i]);
    }
  }
}
//打印模板
template<typename T>
void myPrint(T arr[], int len)
{
  for (int i = 0; i < len; i++)
  {
    cout << arr[i] << "  ";
  }
}
void test01()
{
  int arr1[10] = { 3,6,5,8,9,7,2,1,4,10 };
  int len = sizeof(arr1) / sizeof(arr1[0]);
  mySort(arr1, len);
  myPrint(arr1, len);
  cout << endl;
}
void test02()
{
  char arr2[10] = "bdcfeagh";
  int num = sizeof(arr2) / sizeof(char);
  mySort(arr2, num);
  myPrint(arr2, num);

}
int main()
{
  test01();
  test02();
  system("pause");
  return 0;
}

1.2.4 普通函数与函数模板的区别

普通函数与函数模板区别：

• 普通函数调用时可以发生自动类型转换（隐式类型转换）
• 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
• 如果利用显示指定类型的方式，可以发生隐式类型转换

#include<iostream>
using namespace std;
int myadd01(int a, int b)
{
  int sum = a + b;
  return sum;
}
template<class T>
T myadd02(T a, T b)
{
  T sum = a + b;
  return sum;
}
void test()
{
  int a = 2;
  int b = 3;
  char c = 'c';
  int ret01 = myadd01(a, c);//自动发生强制类型转换，字符‘c’的ASCII码 99
  cout << "ret01= " << ret01;
  int ret02 = myadd02(a, b);
  //int ret03 = myadd02(a, c);//自动类型推导的时候不会发生强制类型转换
  int ret04 = myadd02<int>(a, c);//指定显示类型时可以发生强制类型转换
  cout << "ret02= " << ret02 << endl;
  cout << "ret04= " << ret04 << endl;
}
int main()
{
  test();
  system("pause");
  return 0;
}

总结：建议使用显示指定类型的方式，调用函数模板，因为可以自己确定通用类型T

1.2.5 普通函数与函数模板的调用规则

调用规则如下：

1. 如果函数模板和普通函数都可以实现，优先调用普通函数
2. 可以通过空模板参数列表来强制调用函数模板
3. 函数模板也可以发生重载
4. 如果函数模板可以产生更好的匹配,优先调用函数模板

#include<iostream>
using namespace std;
void myprint(int a, int b)
{
  cout << "调用普通函数" << endl;
}
template<class T>
void myprint(T a, T b)
{
  cout << "调用函数模板" << endl;
}
template<class T>
void myprint(T a, T b, T c)
{
  cout << "调用函数模板 2" << endl;
}
void test01()
{
  //1.普通函数和函数模板都可以实现的时候优先调用普通函数
  int a = 2;
  int b = 3;
  myprint(a, b);
  //2. 可以通过空模板参数列表来强制调用函数模板
  myprint<int>(a, b);
  ////3、函数模板也可以发生重载
  int c = 5;
  myprint(a, b, c);
  //4、 如果函数模板可以产生更好的匹配,优先调用函数模板
  double e = 2.23;
  double d = 3.14;
  myprint(c, d);
}
int main()
{
  test01();
  system("pause");
  return 0;
}

总结：既然提供了函数模板，最好就不要提供普通函数，否则容易出现二义性

1.2.6 模板的局限性

局限性：

• 模板的通用性并不是万能的

template<class T>
    void f(T a, T b)
    { 
        a = b;
    }

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

template<class T>
    void f(T a, T b)
    { 
        if(a > b) { ... }
    }

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行

因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

#include<iostream>
using namespace std;

#include <string>

class Person
{
public:
  Person(string name, int age)
  {
    this->m_Name = name;
    this->m_Age = age;
  }
  string m_Name;
  int m_Age;
};

//普通函数模板
template<class T>
bool myCompare(T& a, T& b)
{
  if (a == b)
  {
    return true;
  }
  else
  {
    return false;
  }
}


//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板
template<> bool myCompare(Person &p1, Person &p2)
{
  if ( p1.m_Name  == p2.m_Name && p1.m_Age == p2.m_Age)
  {
    return true;
  }
  else
  {
    return false;
  }
}

void test01()
{
  int a = 10;
  int b = 20;
  //内置数据类型可以直接使用通用的函数模板
  bool ret = myCompare(a, b);
  if (ret)
  {
    cout << "a == b " << endl;
  }
  else
  {
    cout << "a != b " << endl;
  }
}

void test02()
{
  Person p1("Tom", 10);
  Person p2("Tom", 10);
  //自定义数据类型，不会调用普通的函数模板
  //可以创建具体化的Person数据类型的模板，用于特殊处理这个类型
  bool ret = myCompare(p1, p2);
  if (ret)
  {
    cout << "p1 == p2 " << endl;
  }
  else
  {
    cout << "p1 != p2 " << endl;
  }
}

int main() {

  test01();

  test02();

  system("pause");

  return 0;
}

总结：

• 利用具体化的模板，可以解决自定义类型的通用化
• 学习模板并不是为了写模板，而是在STL能够运用系统提供的模板

1.3 类模板

1.3.1 类模板语法

类模板作用：

• 建立一个通用类，类中的成员 数据类型可以不具体制定，用一个虚拟的类型来代表。

template<typename T>

解释：

template --- 声明创建模板

typename --- 表面其后面的符号是一种数据类型，可以用class代替

T --- 通用的数据类型，名称可以替换，通常为大写字母

#include <string>
#include<iostream>
using namespace std;
//类模板
template<class NameType, class AgeType>
class Person
{
public:
  Person(NameType name, AgeType age)
  {
    this->mName = name;
    this->mAge = age;
  }
  void showPerson()
  {
    cout << "name: " << this->mName << " age: " << this->mAge << endl;
  }
public:
  NameType mName;
  AgeType mAge;
};

void test01()
{
  // 指定NameType 为string类型，AgeType 为 int类型
  Person<string, int>P1("孙悟空", 999);
  P1.showPerson();
}

int main() {

  test01();

  system("pause");

  return 0;
}

总结：类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板

1.3.2 类模板与函数模板的区别

类模板与函数模板区别主要有两点：

1. 类模板没有自动类型推导的使用方式
2. 类模板在模板参数列表中可以有默认参数

#include<iostream>
using namespace std;
#include<string>
template<class NameType,class AgeType=int>
class Person
{
public:
  Person(NameType name, AgeType age)
  {
    this->m_name = name;
    this->m_age = age;
  }
  void showPerson()
  {
    cout << "name: " << this->m_name << " age: " << this->m_age << endl;
  }
public:
  NameType m_name;
  AgeType m_age;

};
void test()
{
  Person<string, int> p1("孙悟空", 999);
  p1.showPerson();
  Person<string> p2("猪悟能", 888);
  p2.showPerson();
}

int main()
{
  test();


  system("pause");
  return 0;
}

总结：

• 类模板使用只能用显示指定类型方式
• 类模板中的模板参数列表可以有默认参数

1.3.3 类模板中成员函数创建时机

类模板中成员函数和普通类中成员函数创建时机是有区别的：

• 普通类中的成员函数一开始就可以创建
• 类模板中的成员函数在调用时才创建

class Person1
{
public:
  void showPerson1()
  {
    cout << "Person1 show" << endl;
  }
};

class Person2
{
public:
  void showPerson2()
  {
    cout << "Person2 show" << endl;
  }
};

template<class T>
class MyClass
{
public:
  T obj;

  //类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再生成

  void fun1() { obj.showPerson1(); }
  void fun2() { obj.showPerson2(); }

};

void test01()
{
  MyClass<Person1> m;
  
  m.fun1();

  //m.fun2();//编译会出错，说明函数调用才会去创建成员函数
}

int main() {

  test01();

  system("pause");

  return 0;
}

总结：类模板中的成员函数并不是一开始就创建的，在调用时才去创建

1.3.4 类模板对象做函数参数

学习目标：

• 类模板实例化出的对象，向函数传参的方式

一共有三种传入方式：

1. 指定传入的类型 --- 直接显示对象的数据类型
2. 参数模板化 --- 将对象中的参数变为模板进行传递
3. 整个类模板化 --- 将这个对象类型 模板化进行传递

#include<iostream>
using namespace std;
#include<string>
template<class NameType,class AgeType=int>
class Person
{
public:
  Person(NameType name, AgeType age)
  {
    this->m_name = name;
    this->m_age = age;
  }
  void showPerson()
  {
    cout << "name: " << this->m_name << " age: " << this->m_age << endl;
  }
public:
  NameType m_name;
  AgeType m_age;

};
void Person1(Person<string, int> p1)
{
  p1.showPerson();
}
void test01()
{
  Person<string, int> p1("孙悟空", 999);
  Person1(p1);
}
template <class T1, class T2>
void printPerson2(Person<T1, T2>& p)
{
  p.showPerson();
  cout << "T1的类型为： " << typeid(T1).name() << endl;
  cout << "T2的类型为： " << typeid(T2).name() << endl;
}
void test02()
{
  Person <string, int >p("猪八戒", 90);
  printPerson2(p);
}
template<class T>
void printPerson3(T& p)
{
  cout << "T的类型为： " << typeid(T).name() << endl;
  p.showPerson();

}
void test03()
{
  Person <string, int >p("唐僧", 30);
  printPerson3(p);
}
int main()
{
  test01();
  test02();
  test03();
  system("pause");
  return 0;
}

总结：

• 通过类模板创建的对象，可以有三种方式向函数中进行传参
• 使用比较广泛是第一种：指定传入的类型

1.3.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

• 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
• 如果不指定，编译器无法给子类分配内存
• 如果想灵活指定出父类中T的类型，子类也需变为类模板

template<class T>
class Base
{
  T m;
};

//class Son:public Base  //错误，c++编译需要给子类分配内存，必须知道父类中T的类型才可以向下继承
class Son :public Base<int> //必须指定一个类型
{
};
void test01()
{
  Son c;
}

//类模板继承类模板 ,可以用T2指定父类中的T类型
template<class T1, class T2>
class Son2 :public Base<T2>
{
public:
  Son2()
  {
    cout << typeid(T1).name() << endl;
    cout << typeid(T2).name() << endl;
  }
};

void test02()
{
  Son2<int, char> child1;
}


int main() {

  test01();

  test02();

  system("pause");

  return 0;
}

总结：如果父类是类模板，子类需要指定出父类中T的数据类型

1.3.6 类模板成员函数类外实现

#include <string>

//类模板中成员函数类外实现
template<class T1, class T2>
class Person {
public:
  //成员函数类内声明
  Person(T1 name, T2 age);
  void showPerson();

public:
  T1 m_Name;
  T2 m_Age;
};

//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
  this->m_Name = name;
  this->m_Age = age;
}

//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson() {
  cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

void test01()
{
  Person<string, int> p("Tom", 20);
  p.showPerson();
}

int main() {

  test01();

  system("pause");

  return 0;
}

总结：类模板中成员函数类外实现时，需要加上模板参数列表

1.3.7 类模板与友元

学习目标：

• 掌握类模板配合友元函数的类内和类外实现

全局函数类内实现 - 直接在类内声明友元即可

全局函数类外实现 - 需要提前让编译器知道全局函数的存在

#include <string>

//2、全局函数配合友元  类外实现 - 先做函数模板声明，下方在做函数模板定义，在做友元
template<class T1, class T2> class Person;

//如果声明了函数模板，可以将实现写到后面，否则需要将实现体写到类的前面让编译器提前看到
//template<class T1, class T2> void printPerson2(Person<T1, T2> & p); 

template<class T1, class T2>
void printPerson2(Person<T1, T2> & p)
{
  cout << "类外实现 ---- 姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
  //1、全局函数配合友元   类内实现
  friend void printPerson(Person<T1, T2> & p)
  {
    cout << "姓名： " << p.m_Name << " 年龄：" << p.m_Age << endl;
  }


  //全局函数配合友元  类外实现
  friend void printPerson2<>(Person<T1, T2> & p);

public:

  Person(T1 name, T2 age)
  {
    this->m_Name = name;
    this->m_Age = age;
  }


private:
  T1 m_Name;
  T2 m_Age;

};

//1、全局函数在类内实现
void test01()
{
  Person <string, int >p("Tom", 20);
  printPerson(p);
}


//2、全局函数在类外实现
void test02()
{
  Person <string, int >p("Jerry", 30);
  printPerson2(p);
}

int main() {

  //test01();

  test02();

  system("pause");

  return 0;
}

总结：建议全局函数做类内实现，用法简单，而且编译器可以直接识别