C++函数模板与类模板实例解析

2025-05-27 0 42

本文针对C++函数模板类模板进行了较为详尽的实例解析,有助于帮助读者加深对C++函数模板类模板的理解。具体内容如下:

泛型编程(Generic Programming)是一种编程范式,通过将类型参数化来实现在同一份代码上操作多种数据类型,泛型是一般化并可重复使用的意思。泛型编程最初诞生于C++中,目的是为了实现C++的STL(标准模板库)。

模板(template)是泛型编程的基础,一个模板就是一个创建类或函数的蓝图或公式。例如,当使用一个vector这样的泛型类型或者find这样的泛型函数时,我们提供足够的信息,将蓝图转换为特定的类或函数。

一、函数模板

一个通用的函数模板(function template)就是一个公式,可用来生成针对特定类型或特定值的函数版本。模板定义以关键字template开始,后面跟一个模板参数列表,列表中的多个模板参数(template parameter)以逗号分隔。模板参数表示在类或函数定义中用到的类型或值。

1、类型参数

一个模板类型参数(type parameter)表示的是一种类型。我们可以将类型参数看作类型说明符,就像内置类型或类类型说明符一样使用。类型参数前必须使用关键字class 或typename:

?

1

2

3

4

5

6

7
template <typename T> // typename和class一样的

T function(T* p)

{

T tmp = *p; // 临时变量类型为T

//...

return tmp; // 返回值类型为T

}

关键字typename和class是一样的作用,但显然typename比class更为直观,它更清楚地指出随后的名字是一个类型名。

编译器用模板类型实参为我们实例化(instantiate)特定版本的函数,一个版本称做模板的一个实例(instantiation)。当我们调用一个函数模板时,编译器通常用函数实参来为我们推断模板实参。当然如果函数没有模板类型的参数,则我们需要特别指出来:

?

1

2

3

4
int a = 10;

cout << function(&a) << endl; // 编译器根据函数实参推断模板实参

cout << function<int>(&a) << endl; // <int>指出模板参数为int

2、非类型参数

在模板中还可以定义非类型参数(nontype parameter),一个非类型参数表示一个值而非一个类型。我们通过一个特定的类型名而非关键字class或typename来指定非类型参数:

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40
// 整形模板

template<unsigned M, unsigned N>

void add()

{

cout<< M+N << endl;

}

// 指针

template<const char* C>

void func1(const char* str)

{

cout << C << " " << str << endl;

}

// 引用

template<char (&R)[9]>

void func2(const char* str)

{

cout << R << " " << str << endl;

}

// 函数指针

template<void (*f)(const char*)>

void func3(const char* c)

{

f(c);

}

void print(const char* c) { cout << c << endl;}

char arr[9] = "template"; // 全局变量,具有静态生存期

int main()

{

add<10, 20>();

func1<arr>("pointer");

func2<arr>("reference");

func3<print>("template function pointer");

return 0;

}

当实例化时,非类型参数被一个用户提供的或编译器推断出的值所替代。一个非类型参数可以是一个整型,或者是一个指向对象或函数的指针或引用:绑定到整形(非类型参数)的实参必须是一个常量表达式,绑定到指针或引用(非类型参数)的实参必须具有静态的生存期(比如全局变量),不能把普通局部变量 或动态对象绑定到指针或引用的非类型形参。

二、类模板

相应的,类模板(class template)是用来生成类的蓝图。与函数模板的不同之处是,编译器不能为类模板推断模板参数类型,所以我们必须显式的提供模板实参。与函数模板一样,类模板参数可以是类型参数,也可以是非类型参数,这里就不再赘述了。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40
template<typename T>

class Array {

public:

Array(T arr[], int s);

void print();

private:

T *ptr;

int size;

};

// 类模板外部定义成员函数

template<typename T>

Array<T>::Array(T arr[], int s)

{

ptr = new T[s];

size = s;

for(int i=0; i<size; ++i)

ptr[i]=arr[i];

}

template<typename T>

void Array<T>::print()

{

for(int i=0; i<size; ++i)

cout << " " << *(ptr+i);

cout << endl;

}

int main()

{

char a[5] = {'J','a','m','e','s'};

Array<char> charArr(a, 5);

charArr.print();

int b[5] = { 1, 2, 3, 4, 5};

Array<int> intArr(b, 5);

intArr.print();

return 0;

}

类模板的成员函数

与其他类一样,我们既可以在类模板内部,也可以在类模板外部定义其成员函数。定义在类模板之外的成员函数必须以关键字template开始,后接类模板参数列表。

?

1

2
template <typename T>

return_type class_name<T>::member_name(parm-list) { }

默认情况下,对于一个实例化了的类模板,其成员函数只有在使用时才被实例化。如果一个成员函数没有被使用,则它不会被实例化。

类模板和友元

当一个类包含一个友元声明时,类与友元各自是否是模板是相互无关的。如果一个类模板包含一个非模板的友元,则友元被授权可以访问所有模板的实例。如果友元自身是模板,类可以授权给所有友元模板的实例,也可以只授权给特定实例。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18
// 前置声明,在将模板的一个特定实例声明为友元时要用到

template<typename T> class Pal;

// 普通类

class C {

friend class Pal<C>; // 用类C实例化的Pal是C的一个友元

template<typename T> friend class Pal2; //Pal2所有实例都是C的友元;无须前置声明

};

// 模板类

template<typename T> class C2 {

// C2的每个实例将用相同类型实例化的Pal声明为友元,一对一关系

friend class Pal<T>;

// Pal2的所有实例都是C2的每个实例的友元,不需要前置声明

template<typename X> friend class Pal2;

// Pal3是普通非模板类,它是C2所有实例的友元

friend class Pal3;

};

类模板的static成员

类模板可以声明static成员。类模板的每一个实例都有其自己独有的static成员对象,对于给定的类型X,所有class_name<X>类型的对象共享相同的一份static成员实例。

?

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28
template<typename T>

class Foo {

public:

void print();

//...其他操作

private:

static int i;

};

template<typename T>

void Foo<T>::print()

{

cout << ++i << endl;

}

template<typename T>

int Foo<T>::i = 10; // 初始化为10

int main()

{

Foo<int> f1;

Foo<int> f2;

Foo<float> f3;

f1.print(); // 输出11

f2.print(); // 输出12

f3.print(); // 输出11

return 0;

}

我们可以通过类类型对象来访问一个类模板的static对象,也可以使用作用域运算符(::)直接访问静态成员。类似模板类的其他成员函数,一个static成员函数也只有在使用时才会实例化。

收藏 (0) 打赏

感谢您的支持,我会继续努力的!

打开微信/支付宝扫一扫,即可进行扫码打赏哦,分享从这里开始,精彩与您同在
点赞 (0)

声明:本站所有文章,如无特殊说明或标注,均为本站原创发布。任何个人或组织,在未征得本站同意时,禁止复制、盗用、采集、发布本站内容到任何网站、书籍等各类媒体平台。如若本站内容侵犯了原著者的合法权益,可联系我们进行处理。

快网idc优惠网 建站教程 C++函数模板与类模板实例解析 https://www.kuaiidc.com/76027.html

相关文章

发表评论
暂无评论