泛型编程的第一步,掌握模板的特性!

栏目: IT技术 · 发布时间: 4年前

内容简介:认识C++ 是很强大,有各种特性来提高代码的可重用性,有助于减少开发的代码量和工作量。

 1  

认识

C++ 是很强大,有各种特性来提高代码的可重用性,有助于减少开发的代码量和工作量。

C++ 提高代码的可重用性主要有两方面:

  • 继承

  • 模板

继承的特性我已在前面篇章写过了「 C++ 一篇搞懂继承的常见特性 」。

本篇主要是说明「模板」的特性, 使用 「模板」的特性设计,实际上也就是「泛型」程序设计。

 2  

函数模板

||   01 变量交换函数模板

假设我们设 计一个交换两个整型变量的值的函数,代码如下:

// 交换两个整型变量的值的Swap函数:

void Swap(int & x,int & y)

{

int tmp = x;

x = y;

y = tmp;

}

如果是浮点类型的变量的值交换,则需要把替换 int 类型为 double 即可,代码如下:

// 交换两个double型变量的值的Swap函数:

void Swap(double & x,double & y)

{

double tmp = x;

x = y;

y = tmp;

}

那如果是其他变量类型的值交换,那不是每次都要重新写一次  Swap  函数? 是不是很繁琐? 且代码后面会越来越冗余。

能否只写一个  Swap  函数,就能交换各种类型的变量?

答案是肯定有的,就是用「函数模板」来解决,「函数模板」的形式:

template <class 类型参数1,class 类型参数2,...>

返回值类型 模板名 (形参表)

{

函数体

};

具体  Swap  「函数模板」代码如下:

template <class T>

void Swap(T & x,T & y)

{

T tmp = x;

x = y;

y = tmp;

}

template  就是模板定义的关键词, T  代表的是任意变量的类型。

那么定义好「函数模板」后,在编译的时候,编译器会根据传入  Swap  函数的参数变量类型,自动生成对应参数变量类型的  Swap  函数:

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(double & ,double & )函数

return 0;

}

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

  • 第 7 行 编译器自动生成 void Swap(double &,  double  & ) 函数。

面的实例化函数模板的例子,是让编译器自己来判断传入的变量类型,那么我们也可以自己指定函数模板的变量类型,具体代码如下:

int main()

{

int n = 1,m = 2;

Swap<int>(n,m); // 指定模板函数的变量类型为int

double f = 1.2,g = 2.3;

Swap<double>(f,g); // 指定模板函数的变量类型为double

return 0;

}

  • 第 4 行指定模板函数的变量类型为 int ;

  • 第 7 行指定模板函数的变量类型为 double 。

— —

||   02 查询数组最大值函数模板

在举一个例子,下面的  MaxElement  函数定义成了函数模板,这样不管是 int、double、char 等类型的数组,都可以使用该函数来查数组最大的值,代码如下:

// 求数组最大元素的MaxElement函数模板

template <class T>

T MaxElement(T a[], int size) // size是数组元素个数

{

T tmpMax = a[0];

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

{

if(tmpMax < a[i])

{

tmpMax = a[i];

}

}

return tmpMax;

}

— —

||   03 多个类型参数模板函数

函数模板中,可以不止一个类型的参数:

template <class T1, class T2>

T2 MyFun(T1 arg1, T2 arg2)

{

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

return arg2;

}

T1  是传入的第一种任意变量类型, T2  是传入的第二种任意变量类型。

— —

||   04 函数模板的重载

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

见下面的例子:

// 模板函数 1

template<class T1, class T2>

void print(T1 arg1, T2 arg2)

{

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

}


// 模板函数 2

template<class T>

void print(T arg1, T arg2)

{

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

}


// 模板函数 3

template<class T,class T2>

void print(T arg1, T arg2)

{

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

}

上面都是  print(参数1, 参数2)  模板函数的重载,因为「形参表」或「类型参数表」名字不同。

— —

||   05 函数模板和函数的次序

在有多个函数和函数模板名字相同的情况下,编译器如下规则处理一条函数调用语句:

  1. 先找参数完全匹配的普通函数(非由模板实例化而得的函数);

  2. 再找参数完全匹配的模板函数;

  3. 再找实参数经过自动类型转换后能够匹配的普通函数;

  4. 上面的都找不到,则报错。

代码例子如下:

// 模板函数 - 1个参数类型

template <class T>

T Max(T a, T b)

{

cout << "TemplateMax" <<endl; return 0;

}


// 模板函数 - 2个参数类型

template <class T, class T2>

T Max(T a, T2 b)

{

cout << "TemplateMax2" <<endl; return 0;

}


// 普通函数

double Max(double a, double b)

{

cout << "MyMax" << endl;

return 0;

}


int main()

{

int i=4, j=5;

// 输出MyMax - 匹配普通函数

Max( 1.2, 3.4 );

//输出TemplateMax - 匹配参数一样的模板函

Max( i, j );

//输出TemplateMax2 - 匹配参数类型不同的模板函数

Max( 1.2, 3 );

return 0;

}

  • 第 27 行,输出的是MyMax,因为匹配的是普通函数;

  • 第 30 行,输出的是输出TemplateMax,因为匹配参数一样的模板函;

  • 第 33 行,输出的是TemplateMax2,因为匹配参数类型不同的模板函数。

匹配模板函数时,当模板函数只有一个参数类型时,传入了不同的参数类型,是不进行类型自动转换,具体例子如下:

// 模板函数 - 1个参数类型

template<class T>

T myFunction( T arg1, T arg2)

{

cout<<arg1<<" "<<arg2<<"\n";

return arg1;

}


...


// OK :替换 T 为 int 类型

myFunction( 5, 7);


// OK :替换 T 为 double 类型

myFunction(5.8, 8.4);


// error :没有匹配到myFunction(int, double)函数

myFunction(5, 8.4);

  • 第 12 行,可以正常执行,替换 T 为 int 类型;

  • 第 15 行,可以正常执行,替换 T 为 double 类型 ;

  • 第 18 行,会执行错误!因为没有匹配到 myFunction(int, double)函数。

 3  

类模板

||   01 类模板的定义

为了多快好省地定义出一批 相似的类, 可以定义「类模板」,然后 由类模板生成不同的类

类模板的定义形式如下:

template <class 类型参数1class 类型参数2,...> //类型参数表

class 类模板名

{

成员函数和成员变量

};

用类模板定义对象的写法:

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

— —

||   02 Pair类模板例子

接下来,用 Pair 类用类模板的方式的实现,Pair 是一对的意思,也就是实现一个键值对(key-value)的关系的类。

代码如下:

// 类模板

template <class T1, class T2>

class Pair

{

public:

Pair(T1 k, T2 v):m_key(k),m_value(v) {};

bool operator < (const Pair<T1,T2> & p) const;

private:

T1 m_key;

T2 m_value;

};


// 类模板里成员函数的写法

template <class T1, class T2>

bool Pair<T1,T2>::operator < (const Pair<T1,T2> &p) const

{

return m_value < p.m_value;

}


int main()

{

Pair<string,int> Astudent("Jay",20);

Pair<string,int> Bstudent("Tom",21);

cout << (Astudent < Bstudent) << endl;

return 0;

}

输出结果:

需要注意的是,同一个类模板的两个模板类是不兼容的:

Pair<string,int> *p;

Pair<string,double> a;

p = & a; //错误!!

— —

||  03 函数模板作为类模板成员

当函数模板作为类模板的成员函数时,是可以单独写成函数模板的形式,成员函数模板在使用的时候,编译器才会把函数模板根据传入的函数参数进行实例化,例子如下:

// 类模板

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;

}

— —

||  04 类模板与非类型参数

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

template <class T, int size>

class CArray

{

public:

void Print( )

{

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

cout << array[i] << endl;

}

private:

T array[size];

};


CArray<double,40> a2;

CArray<int,50> a3; //a2和a3属于不同的类

 4  

类模板和派生

||  01 类模板从类模板派生

泛型编程的第一步,掌握模板的特性!

上图的代码例子如下:

// 基类 - 类模板

template <class T1,class T2>

class A

{

T1 v1; T2 v2;

};


// 派生类 - 类模板

template <class T1,class T2>

class B:public A<T2,T1>

{

T1 v3; T2 v4;

};


// 派生类 - 类模板

template <class T>

class C:public B<T,T>

{

T v5;

};


int main()

{

B<int,double> obj1;

C<int> obj2;

return 0;

}

— —

||  02 类模板从模板类派生

泛型编程的第一步,掌握模板的特性!

上图的代码例子如下:

template <class T1,class T2>

class A

{

T1 v1; T2 v2;

};


template <class T>

class B:public A<int,double> // A<int,double> 模板类

{

T v;

};


int main()

{

//自动生成两个模板类 :A<int,double> 和 B<char>

B<char> obj1;

return 0;

}

  • 第 16 行,在创建 B类 对象,会自动生成两个模板类 :A<int,double> 和 B<char> 。

— —

||  03 类模板从普通类派生

泛型编程的第一步,掌握模板的特性!

上图的代码例子如下:

// 基类 - 普通类

class A

{

int v1;

};


// 派生类 - 类模板

template <class T>

class B:public A // 所有从B实例化得到的类 ,都以A为基类

{

T v;

};


int main()

{

B<char> obj1;

return 0;

}

  • 第 16 行,在创建 B 类对象前,会先构造基类 A 对象。

— —

||  04 普通类从模板类派生

泛型编程的第一步,掌握模板的特性!

上图的代码例子如下:

template <class T>

class A

{

T v1;

};


class B : public A<int>

{

double v;

};


int main()

{

B obj1;

return 0;

}

  • 第 14 行,在构造 B 类对象前,会先实例化 A 模板对象。

 5  

类模板与友元

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

代码例子如下:

// 普通函数

void Func1() { }


// 普通类

class A { };


// 普通类

class B

{

public:

void Func() { } // 成员函数

};


// 类模板

template <class T>

class Tmp

{

friend void Func1(); // 友元函数

friend class A; // 友元类

friend void B::Func(); // 友元类的成员函数

}; // 任何从 Tmp 实例化来的类 ,都有以上三个友元

任何从 Tmp 实例化来的类 ,都有以上三个友元。

— —

||  02 函数模板作为类模板的友元

// 类模板

template <class T1,class T2>

class Pair

{

private:

T1 key; //关键字

T2 value; //值

public:

Pair(T1 k,T2 v):key(k),value(v) { };

// 友元函数模板

template <class T3,class T4>

friend ostream & operator<< (ostream & o, const Pair<T3,T4> & p);

};


// 函数模板

template <class T3,class T4>

ostream & operator<< (ostream & o, const Pair<T3,T4> & 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)

— —

||  03 函数模板作为类的友元

// 普通类

class A

{

private:

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;

}

输出结果:

— —

||   04 类模板作为类模板的友元

// 类模板

template <class T>

class B

{

private:

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); // 实例化B模板类

cout << o.v << endl;

}

};


int main()

{

A<double> a;

a.Func ();

return 0;

}

输出结果:

 6  

类模板与静态成员函数

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

见下面的例子:

template <class T>

class A

{

private:

static int count; // 静态成员

public:

A() { count ++; }

~A() { count -- ; };

A( A & ) { count ++ ; }

static void PrintCount() // 静态函数

{

cout << count << endl;

}

};


template<> int A<int>::count = 0; // 初始化

template<> int A<double>::count = 0; // 初始化


int main()

{

A<int> ia;

A<double> da; // da和ia不是相同模板类

ia.PrintCount();

da.PrintCount();

return 0;

}

输出:

上面的代码需要注意的点:

  • 类模板里的静态成员初始化的时候,最前面要加 template<>
  • ia 和 da 对象是不同的模板类,因为类型参数是不一致,所以也就是不同的模板类。


以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持 码农网

查看所有标签

猜你喜欢:

本站部分资源来源于网络,本站转载出于传递更多信息之目的,版权归原作者或者来源机构所有,如转载稿涉及版权问题,请联系我们

轻营销

轻营销

唐文 / 机械工业出版社 / 2015-6 / 35元

《轻营销》,中国第一本全面讲述如何在互联网新时代用小预算做大营销的书籍,以求把中小微企业从那些以大预算为基础而难以落地的营销理论和案例中解脱出来。用“轻”但真正起作用的方法,帮助传统企业抓住互联网新一波浪潮的机遇,转型升级。 “怒打价格战、拼命砸广告、渠道金字塔”是过去中国企业做营销的基本功课,背后的逻辑是花钱。今天这三招已经不太管用了,广告费用的多少不再是决定性因素。取而代之的是直面客户的......一起来看看 《轻营销》 这本书的介绍吧!

JSON 在线解析
JSON 在线解析

在线 JSON 格式化工具

RGB CMYK 转换工具
RGB CMYK 转换工具

RGB CMYK 互转工具