C++入门C++ 函数模板&类模板

Posted BkbK-

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了C++入门C++ 函数模板&类模板相关的知识，希望对你有一定的参考价值。

C++函数模板&类模板


文章目录

一、函数模板

1.函数模板的定义

template <class 类型参数1，class 类型参数2,……>
返回值类型 模板名 (形参表) 
	函数体
;

2.函数模板的实例化

  • 通过参数实例化：

    • 交换两个变量函数模板：

      template <class T>
void Swap(T &x, T &y)

    T tmp = x;
    x = y;
    y = tmp;

int main()

    int n = 1, m = 2;
    Swap(n, m); //编译器自动生成 void Swap(int & ,int & )函数
    double f = 1.2, g = 2.3;
    Swap(f, g); //编译器自动生成 void Swap(int & ,int & )函数
    return 0;

    • 编译器自动生成 void Swap(int & ,int & )函数

      void Swap(int &x, int &y)

    int tmp = x;
    x = y;
    y = tmp;

    • 编译器自动生成 void Swap(int & ,int & )函数

      void Swap(double &x, double &y)

    double tmp = x;
    x = y;
    y = tmp;

  • 不通过参数实例化：
    直接调用 函数名<类型参数列表>(参数列表)

    #include <iostream>
using namespace std;
template <class T>
T Inc(T n)

    return 1 + n;

int main()

    cout << Inc<double>(4) / 2; //输出 2.5
    return 0;

3.函数模板的重载

函数模板可以重载，只要它们的形参表或类型参数表不同即可。

template <class T1, class T2>
void print(T1 arg1, T2 arg2)

    cout << arg1 << " " << arg2 << endl;


template <class T>
void print(T arg1, T arg2)

    cout << arg1 << " " << arg2 << endl;


template <class T, class T2>
void print(T arg1, T arg2)

    cout << arg1 << " " << arg2 << endl;

4.函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句：（匹配模板函数时，不进行类型自动转换）

    1. 先找参数完全匹配的普通函数(非由模板实例化而得的函数)。
    1. 再找参数完全匹配的模板函数。
    1. 再找实参数经过自动类型转换后能够匹配的普通函数。
    1. 上面的都找不到，则报错。

5.函数模板示例：Map

  • 代码：

    #include <iostream>
using namespace std;
template <class T, class Pred>
void Map(T s, T e, T x, Pred op)

    for (; s != e; ++s, ++x)
    
        *x = op(*s);
    

int Cube(int x)  return x * x * x; 
double Square(double x)  return x * x; 
int a[5] = 1, 2, 3, 4, 5, b[5];
double d[5] = 1.1, 2.1, 3.1, 4.1, 5.1, c[5];
int main()

    Map(a, a + 5, b, Square);
    for (int i = 0; i < 5; ++i)
        cout << b[i] << ",";
    cout << endl;
    Map(a, a + 5, b, Cube);
    for (int i = 0; i < 5; ++i)
        cout << b[i] << ",";
    cout << endl;
    Map(d, d + 5, c, Square);
    for (int i = 0; i < 5; ++i)
        cout << c[i] << ",";
    cout << endl;
    return 0;

  • 输出：

    1,4,9,16,25,
    1,8,27,64,125,
    1.21,4.41,9.61,16.81,26.01,

  • 实例化：

    Map(a, a + 5, b, Square); //实例化出以下函数:
void Map(int *s, int *e, int *x, double (*op)(double))

    for (; s != e; ++s, ++x)
    
        *x = op(*s);

二、类模板

1.类模板的定义

  • 类模板：

    在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。

  • 模板类的写法：

    template <class 类型参数1，class 类型参数2，……> //类型参数表
class 类模板名

	成员函数和成员变量
;

  • 类模板里成员函数的写法：

    template <class 类型参数1，class 类型参数2，……> //类型参数表
返回值类型 类模板名<类型参数名列表>::成员函数名（参数表）
 
	……

  • 用类模板定义对象的写法：
    编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。

    类模板名 <真实类型参数表> 对象名(构造函数实参表);

    • 同一个类模板的两个模板类是不兼容的：

      Pair<string,int> * p;
Pair<string,double> a;
p = & a; //wrong

  • 类模板示例： Pair类模板：

    template <class T1, class T2>
class Pair

public:
    T1 key;   //关键字
    T2 value; //值
    Pair(T1 k, T2 v) : key(k), value(v);
    bool operator<(const Pair<T1, T2> &p) const;
;
template <class T1, class T2>
bool Pair<T1, T2>::operator<(const Pair<T1, T2> &p) const
//Pair的成员函数 operator <

    return key < p.key;

int main()

    Pair<string, int> student("Tom", 19);
    //实例化出一个类 Pair<string,int>
    cout << student.key << " " << student.value;
    return 0;

    输出：
    Tom 19

2.函数模版作为类模板成员

#include <iostream>
using namespace std;
template <class T>
class A

public:
    template <class T2>
    void Func(T2 t)  cout << t;  //成员函数模板
;
int main()

    A<int> a;
    a.Func('K');     //成员函数模板 Func被实例化
    a.Func("hello"); //成员函数模板 Func再次被实例化
    return 0;

输出：KHello

3.类模板与非类型参数

  • 类模板的“<类型参数表>”中可以出现非类型参数：

    template <class T, int size>
class CArray

    T array[size];

public:
    void Print()
    
        for (int i = 0; i < size; ++i)
            cout << array[i] << endl;
    
;
CArray<double, 40> a2;
CArray<int, 50> a3; //a2和a3属于不同的类

4.类模板与派生

  • 类模板从类模板派生

    • 基类A：

      template <class T1, class T2>
class A

    T1 v1;
    T2 v2;
;

    • 派生类B：

      template <class T1, class T2>
class B : public A<T2, T1>

    T1 v3;
    T2 v4;
;

    • B<int,double> obj1;的实例化

      class B<int,double>:
public A<double,int> 
	int v3; double v4;
;

      class A<double, int> 

	double v1; int v2;
;

  • 类模板从模板类派生

    template <class T1, class T2>
class A

    T1 v1;
    T2 v2;
;
template <class T>
class B : public A<int, double>

    T v;
;
int main()

    B<char> obj1; //自动生成两个模板类：A<int,double> 和 B<char>
    return 0;

  • 类模板从普通类派生

    class A

    int v1;
;
template <class T>
class B : public A
 //所有从B实例化得到的类，都以A为基类
    T v;
;
int main()

    B<char> obj1;
    return 0;

  • 普通类从模板类派生

    template <class T>
class A

    T v1;
    int n;
;
class B : public A<int>

    double v;
;
int main()

    B obj1;
    return 0;

5.类模板与友元

  • 函数、类、类的成员函数作为类模板的友元

    void Func1() 
class A

;
class B

public:
    void Func() 
;
template <class T>
class Tmpl

    friend void Func1();
    friend class A;
    friend void B::Func();
; //任何从Tmp1实例化来的类，都有以上三个友元

  • 函数模板作为类模板的友元
    任意从
    template <class T1,class T2>
    ostream & operator<< (ostream & o,const Pair<T1,T2> & p)
    生成的函数，都是任意Pair摸板类的友元

    #include <iostream>
#include <string>
using namespace std;
template <class T1, class T2>
class Pair

private:
    T1 key;   //关键字
    T2 value; //值
public:
    Pair(T1 k, T2 v) : key(k), value(v);
    bool operator<(const Pair<T1, T2> &p) const;
    template <class T3, class T4>
    friend ostream &operator<<(ostream &o,
                               const Pair<T3, T4> &p);
;
template <class T1, class T2>
bool Pair<T1, T2>::operator<(const Pair<T1, T2> &p) const
 //"小"的意思就是关键字小
    return key < p.key;

template <class T1, class T2>
ostream &operator<<(ostream &o, const Pair<T1, T2> &p)

    o << "(" << p.key << "," << p.value << ")";
    return o;

int main()

    Pair<string, int> student("Tom", 29);
    Pair<int, double> obj(12, 3.14);
    cout << student << " " << obj;
    return 0;

    输出：
    (Tom,29) (12,3.14)

  • 函数模板作为类的友元
    所有从 template <class T>
    void Print(const T & p)
    生成的函数，都成为 A 的友元
    但是自己写的函数
    void Print(int a)
    不会成为A的友元

    #include <iostream>
using namespace std;
class A

    int v;

public:
    A(int n) : v(n) 
    template <class T>
    friend void Print(const T &p);
;
template <class T>
void Print(const T &p)

    cout << p.v;

int main()

    A a(4);
    Print(a);
    return 0;

输出：
4

  • 类模板作为类模板的友元
    A< double>类，成了B<int>类的友元。
    任何从A模版实例化出来的类，都是任何B实例化出来的类的友元

    #include <iostream>
using namespace std;
template <class T>
class B

    T v;

public:
    B(T n) : v(n) 
    template <class T2>
    friend class A;
;
template <class T>
class A

public:
    void Func()
    
        B<int> o(10);
        cout << o.v << endl;
    
;
int main()

    A<double> a;
    a.Func();
    return 0;

    输出：
    10

6.类模板与静态成员变量

类模板中可以定义静态成员，那么从该类模板实例化得到的所有类，都包含同样的静态成员。

#include <iostream>
using namespace std;
template <class T>
class A

private:
    static int count;

public:
    A()  count++; 
    ~A()  count--; ;
    A(A &)  count++精选C++类模板5分钟入门教程


 C++模板编程入门模板介绍模板定义函数模板类模板模板的继承


 C++ 提高教程 模板-函数模板和类模板


 C++ ---模板(初识)


 C++模板（函数模板类模板）


 C++模板第一篇：函数模板和类模板