码迷,mamicode.com
首页 > 编程语言 > 详细

C++ 模板与泛型编程

时间:2016-01-14 23:57:05      阅读:412      评论:0      收藏:0      [点我收藏+]

标签:

《C++ Primer 4th》读书笔记

所谓泛型编程就是以独立于任何特定类型的方式编写代码。泛型编程与面向对象编程一样,都依赖于某种形式的多态性。

面向对象编程中的多态性在运行时应用于存在继承关系的类。我们能够编写使用这些类的代码,忽略基类与派生类之间类型上的差异。

在泛型编程中,我们所编写的类和函数能够多态地用于跨越编译时不相关的类型。一个类或一个函数可以用来操纵多种类型的对象。

面向对象编程所依赖的多态性称为运行时多态性,泛型编程所依赖的多态性称为编译时多态性或参数式多态性。

 

模板是泛型编程的基础。模板是创建类或函数的蓝图或公式。

 

函数模板

模板定义以关键字 template 开始,后接模板形参表,模板形参表是用尖括号括住的一个或多个模板形参的列表,形参之间以逗号分隔。模板形参表不能为空。

template <typename T>

int compare(const T &v1, const T &v2)

{

if (v1 < v2) return -1;

if (v2 < v1) return 1;

return 0;

}

 

模板形参可以是表示类型的类型形参,也可以是表示常量表达式的非类型形参。类型形参跟在关键字 class 或 typename 之后定义.在函数模板形参表中,关键字 typename 和 class 具有相同含义,可以互换使用,两个关键字都可以在同一模板形参表中使用:

// ok: no distinction between typename and class in template parameter list

template <typename T, class U> calc (const T&, const U&);

 

模板形参表示可以在类或函数的定义中使用的类型或值。使用函数模板时,编译器会推断哪个(或哪些)模板实参绑定到模板形参。一旦编译器确定了实际的模板实参,就称它实例化了函数模板的一个实例。

实质上,编译器将确定用什么类型代替每个类型形参,以及用什么值代替每个非类型形参。推导出实际模板实参后,编译器使用实参代替相应的模板形参产生编译该版本的函数。编译器承担了为我们使用的每种类型而编写函数的单调工作。

int main ()

{

// T is int;

// compiler instantiates int compare(const int&, const int&)

cout << compare(1, 0) << endl;

// T is string;

// compiler instantiates int compare(const string&, const string&)

string s1 = "hi", s2 = "world";

cout << compare(s1, s2) << endl;

return 0;

}

 

 函数模板可以用与非模板函数一样的方式声明为 inline。说明符放在模板形参表之后、返回类型之前,不能放在关键字 template 之前。

// ok: inline specifier follows template parameter list

template <typename T> inline T min(const T&, const T&);

// error: incorrect placement of inline specifier

inline template <typename T> T min(const T&, const T&);

 

类模板

类模板也是模板,因此必须以关键字 template 开头,后接模板形参表。Queue 模板接受一个名为 Type 的模板类型形参。

除了模板形参表外,类模板的定义看起来与任意其他类问相似。类模板可以定义数据成员、函数成员和类型成员,也可以使用访问标号控制对成员的访问,还可以定义构造函数和析构函数等等。在类和类成员的定义中,可以使用模板形参作为类型或值的占位符,在使用类时再提供那些类型或值。

template <class Type> class Queue {

public:

Queue (); // default constructor

Type &front (); // return element from head of Queue

const Type &front () const;

void push (const Type &); // add element to back of Queue

void pop(); // remove element from head of Queue

bool empty() const; // true if no elements in the Queue

private:

// ...

};

 

与调用函数模板形成对比,使用类模板时,必须为模板形参显式指定实参:

Queue<int> qi; // Queue that holds ints

Queue< vector<double> > qc; // Queue that holds vectors of doubles

Queue<string> qs; // Queue that holds strings

 

除了定义数据成员或函数成员之外,类还可以定义类型成员。如果要在函数模板内部使用这样的类型,必须告诉编译器我们正在使用的名字指的是一个类型。必须显式地这样做,因为编译器(以及程序的读者)不能通过检查得知,由类型形参定义的名字何时是一个类型何时是一个值。如果希望编译器将 size_type 当作类型,则必须显式告诉编译器这样做:

template <class Parm, class U>

Parm fcn(Parm* array, U value)

{

typename Parm::size_type * p; // ok: declares p to be a pointer

}

通过在成员名前加上关键字 typename 作为前缀,可以告诉编译器将成员当作类型。

如果拿不准是否需要以 typename 指明一个名字是一个类型,那么指定它是个好主意。在类型之前指定 typename 没有害处,因此,即使 typename 是不必要的,也没有关系。

 

非类型模板形参

模板形参不必都是类型。模板非类型形参是模板定义内部的常量值,在需要常量表达式的时候,可使用非类型形参(例如,像这里所做的一样)指定数组的长度。

// initialize elements of an array to zero

template <class T, size_t N> void array_init(T (&parm)[N])

{

for (size_t i = 0; i != N; ++i) {

parm[i] = 0;

}

}

int x[42];

double y[10];

array_init(x); // instantiates array_init(int(&)[42]

array_init(y); // instantiates array_init(double(&)[10]

 

类型等价性与非类型形参: 对模板的非类型形参而言,求值结果相同的表达式将认为是等价的。array_init 调用引用的是相同的实例—— array_init<int, 42>:

int x[42];

const int sz = 40;

int y[sz + 2];

array_init(x); // instantiates array_init(int(&)[42])

array_init(y); // equivalent instantiation

 

在函数模板内部完成的操作限制了可用于实例化该函数的类型。程序员的责任是,保证用作函数实参的类型实际上支持所用的任意操作,以及保证在模板使用哪些操作的环境中那些操作运行正常。

 

编写独立于类型的代码的一般原则:编写模板代码时,对实参类型的要求尽可能少是很有益的。说明了编写泛型代码的两个重要原则:

• 模板的形参是 const 引用。

• 函数体中的测试只用 < 比较。

通过将形参设为 const 引用,就可以允许使用不允许复制的类型。大多数类型(包括内置类型和我们已使用过的除 IO 类型之外的所有标准库的类型)都允许复制。但是,也有不允许复制的类类型。将形参设为 const 引用,保证这种类型可以用于 compare 函数,而且,如果有比较大的对象调用 compare,则这个设计还可以使函数运行得更快。

 

实例化

模板是一个蓝图,它本身不是类或函数。编译器用模板产生指定的类或函数的特定类型版本。产生模板的特定类型实例的过程称为实例化。模板在使用时将进行实例化,类模板在引用实际模板类类型时实例化,函数模板在调用它或用它对函数指针进行初始化或赋值时实例化。

 

类模板的每次实例化都会产生一个独立的类类型。为 int 类型实例化的 Queue 与任意其他 Queue 类型没有关系,对其他Queue 类型成员也没有特殊的访问权。

 

从函数实参确定模板实参的类型和值的过程叫做模板实参推断。

 

类型形参的实参的受限转换

一般而论,不会转换实参以匹配已有的实例化,相反,会产生新的实例。除了产生新的实例化之外,编译器只会执行两种转换:

• const 转换:接受 const 引用或 const 指针的函数可以分别用非 const对象的引用或指针来调用,无须产生新的实例化。如果函数接受非引用类型,形参类型实参都忽略 const,即,无论传递 const 或非 const 对象给接受非引用类型的函数,都使用相同的实例化。

• 数组或函数到指针的转换:如果模板形参不是引用类型,则对数组或函数类型的实参应用常规指针转换。数组实参将当作指向其第一个元素的指针,函数实参当作指向函数类型的指针。

template <typename T> T fobj(T, T); // arguments are copied

template <typename T>

T fref(const T&, const T&); // reference arguments

string s1("a value");

const string s2("another value");

fobj(s1, s2); // ok: calls f(string, string), const is ignored

fref(s1, s2); // ok: non const object s1 converted to const reference int a[10], b[42];

fobj(a, b); // ok: calls f(int*, int*)

fref(a, b); // error: array types don‘t match; arguments aren‘t converted to pointers

 

模板实参推断与函数指针

可以使用函数模板对函数指针进行初始化或赋值,这样做的时候,编译器使用指针的类型实例化具有适当模板实参的模板版本。

template <typename T> int compare(const T&, const T&);

// pf1 points to the instantiation int compare (const int&, constint&)

int (*pf1) (const int&, const int&) = compare;

获取函数模板实例化的地址的时候,上下文必须是这样的:它允许为每个模板形参确定唯一的类型或值。如果不能从函数指针类型确定模板实参,就会出错。

// overloaded versions of func; each take a different function pointer type

void func(int(*) (const string&, const string&));

void func(int(*) (const int&, const int&));

func(compare); // error: which instantiation of compare?

 

在返回类型中使用类型形参

指定返回类型的一种方式是引入第三个模板形参,它必须由调用者显式指定:

// T1 cannot be deduced: it doesn‘t appear in the function parameterlist

template <class T1, class T2, class T3>

T1 sum(T2, T3);

// ok T1 explicitly specified; T2 and T3 inferred from argument types

long val3 = sum<long>(i, lng); // ok: calls long sum(int, long)

 

显式模板实参从左至右对应模板形参相匹配,第一个模板实参与第一个模板形参匹配,第二个实参与第二个形参匹配,以此类推。

// poor design: Users must explicitly specify all three template parameters

template <class T1, class T2, class T3>

T3 alternative_sum(T2, T1);

// error: can‘t infer initial template parameters

long val3 = alternative_sum<long>(i, lng);

// ok: All three parameters explicitly specified

long val2 = alternative_sum<long, int, long>(i, lng);

 

模板编译模型

编译器实例化特定类型的模板的时候,编译器必须能够访问定义模板的源代码。当调用函数模板或类模板的成员函数的时候,编译器需要函数定义,需要那些通常放在源文件中的代码。标准 C++ 为编译模板代码定义了两种模型。

在包含编译模型中,编译器必须看到用到的所有模板的定义。一般而言,可以通过在声明函数模板或类模板的头文件中添加一条 #include 指示使定义可用,该#include 引入了包含相关定义的源文件:

// header file utlities.h

#ifndef UTLITIES_H // header gaurd (Section 2.9.2, p. 69)

#define UTLITIES_H

template <class T> int compare(const T&, const T&);

// other declarations

#include "utilities.cc" // get the definitions for compare etc.

#endif

// implemenatation file utlities.cc

template <class T> int compare(const T &v1, const T &v2)

{

if (v1 < v2) return -1;

if (v2 < v1) return 1;

return 0;

}

// other definitions

 

在分别编译模型中,编译器会为我们跟踪相关的模板定义。但是,我们必须让编译器知道要记住给定的模板定义,可以使用 export 关键字来做这件事。对类模板使用 export 更复杂一些。通常,类声明必须放在头文件中

// class template header goes in shared header file

template <class Type> class Queue { ... };

// Queue.ccimplementation file declares Queue as exported

export template <class Type> class Queue;

#include "Queue.h"

// Queue member definitions

导出类的成员将自动声明为导出的。也可以将类模板的个别成员声明为导出的,在这种情况下,关键字 export 不在类模板本身指定,而是只在被导出的特定成员定义上指定。

 

类模板的 static 成员

template <class T> class Foo {

public:

static std::size_t count() { return ctr; }

// other interface members

private:

static std::size_t ctr;

// other implementation members

};

每个实例化表示截然不同的类型,所以给定实例外星人所有对象都共享一个static 成员。因此,Foo<int> 类型的任意对象共享同一 static 成员 ctr,Foo<string> 类型的对象共享另一个不同的 ctr 成员。

 

通常,可以通过类类型的对象访问类模板的 static 成员,或者通过使用作用域操作符直接访问成员。当然,当试图通过类使用 static 成员的时候,必须引用实际的实例化:

Foo<int> fi, fi2; // instantiates Foo<int> class

size_t ct = Foo<int>::count(); // instantiates Foo<int>::count

ct = fi.count(); // ok: uses Foo<int>::count

ct = fi2.count(); // ok: uses Foo<int>::count

ct = Foo::count(); // error: which template instantiation?

与任意其他成员函数一样,static 成员函数只有在程序中使用时才进行实例化。

 

像使用任意其他 static 数据成员一样,必须在类外部出现数据成员的定义。在类模板含有 static 成员的情况下,成员定义必须指出它是类模板的成员:

template <class T> size_t Foo<T>::ctr = 0; // define and initialize ctr

 

一个泛型句柄类

/* generic handle class: Provides pointerlike behavior. Although access through

* an unbound Handle is checked and throws a runtime_error exception.

* The object to which the Handle points is deleted when the last Handle goes away.

* Users should allocate new objects of type T and bind them to a Handle.

* Once an object is bound to a Handle,, the user must not delete that object.

*/

template <class T> class Handle {

public:

// unbound handle

Handle(T *p = 0): ptr(p), use(new size_t(1)) { }

// overloaded operators to support pointer behavior

T& operator*();

T* operator->();

const T& operator*() const;

const T* operator->() const;

// copy control: normal pointer behavior, but last Handle deletes the object

Handle(const Handle& h): ptr(h.ptr), use(h.use)

{ ++*use; }

Handle& operator=(const Handle&);

~Handle() { rem_ref(); }

private:

T* ptr; // shared object

size_t *use; // count of how many Handle spointto *ptr

void rem_ref()

{ if (--*use == 0) { delete ptr; delete use; } }

};

 

template <class T>

inline Handle<T>& Handle<T>::operator=(const Handle &rhs)

{

++*rhs.use; // protect against self-assignment

rem_ref(); // decrement use count and delete pointers if

needed

ptr = rhs.ptr;

use = rhs.use;

return *this;

}

 

template <class T> inline T& Handle<T>::operator*()

{

if (ptr) return *ptr;

throw std::runtime_error("dereference of unbound Handle");

}

template <class T> inline T* Handle<T>::operator->()

{

if (ptr) return ptr;

throw std::runtime_error("access through unbound Handle");

}

 

template <class T> inline const T* Handle<T>::operator->() const

{

           if (ptr) return ptr;

else throw std::logic_error("unbound Sales_item");

 }

 

template <class T> inline const T& Handle<T>:: const

{

           if (ptr) return *ptr;

else throw std::logic_error("unbound Sales_item");

}

 

class Sales_item {

public:

// default constructor: unbound handle

Sales_item(): h() { }

// copy item and attach handle to the copy

Sales_item(const Item_base &item): h(item.clone()) { }

// no copy control members: synthesized versions work

// member access operators: forward their work to the Handle class

const Item_base& operator*() const { return *h; }

const Item_base* operator->() const

{ return h.operator->(); }

private:

Handle<Item_base> h; // use-counted handle

};

 

 

模板特化

模板特化(template specialization)是这样的一个定义,该定义中一个或多个模板形参的实际类型或实际值是指定的。特化的形式如下:

• 关键字 template 后面接一对空的尖括号(<>);

• 再接模板名和一对尖括号,尖括号中指定这个特化定义的模板形参;

• 函数形参表;

• 函数体。

template <typename T>

int compare(const T &v1, const T &v2)

{

if (v1 < v2) return -1;

if (v2 < v1) return 1;

return 0;

}

 

// special version of compare to handle C-style character strings

template <>

int compare<const char*>(const char* const &v1,

const char* const &v2)

{

return strcmp(v1, v2);

}

 

模板特化必须总是包含空模板形参说明符,即 template<>,而且,还必须包含函数形参表。如果可以从函数形参表推断模板实参,则不必显式指定模板实参:

// error: invalid specialization declarations

// missing template<>

int compare<const char*>(const char* const&,

const char* const&);

// error: function parameter list missing

template<> int compare<const char*>;

// ok: explicit template argument const char* deduced from parameter types

template<> int compare(const char* const&, const char* const&);

 

当定义非模板函数的时候,对实参应用常规转换;当特化模板的时候,对实参类型不应用转换。在模板特化版本的调用中,实参类型必须与特化版本函数的形参类型完全匹配,如果不完全匹配,编译器将为实参从模板定义实例化一个实例。

 

与其他函数声明一样,应在一个头文件中包含模板特化的声明,然后使用该特化的每个源文件包含该头文件。

 

普通作用域规则适用于特化

在能够声明或定义特化之前,它所特化的模板的声明必须在作用域中。类似地,在调用模板的这个版本之前,特化的声明必须在作用域中:

// define the general compare template

template <class T>

int compare(const T& t1, const T& t2) { /* ... */ }

int main() {

// uses the generic template definition

int i = compare("hello", "world");

// ...

}

// invalid program: explicit specialization after call

template<>

int compare<const char*>(const char* const& s1,

const char* const& s2)

{ /* ... */ }

 

这个程序有错误,因为在声明特化之前,进行了可以与特化相匹配的一个调用。当编译器看到一个函数调用时,它必须知道这个版本需要特化,否则,编译器将可能从模板定义实例化该函数。

 

重载与函数模板

函数模板可以重载:可以定义有相同名字但形参数目或类型不同的多个函数模板,也可以定义与函数模板有相同名字的普通非模板函数。

 

如果重载函数中既有普通函数又有函数模板,确定函数调用的步骤如下:

1. 为这个函数名建立候选函数集合,包括:

a. 与被调用函数名字相同的任意普通函数。

b. 任意函数模板实例化,在其中,模板实参推断发现了与调用中所用函数实参相匹配的模板实参。

2. 确定哪些普通函数是可行的(第 7.8.2 节)(如果有可行函数的话)。候选集合中的每个模板实例都 可行的,因为模板实参推断保证函数可以被调用。

3. 如果需要转换来进行调用,根据转换的种类排列可靠函数,记住,调用模板函数实例所允许的转换是有限的。

a. 如果只有一个函数可选,就调用这个函数。

b. 如果调用有二义性,从可行函数集合中去掉所有函数模板实例。

4. 重新排列去掉函数模板实例的可行函数。

• 如果只有一个函数可选,就调用这个函数。

• 否则,调用有二义性。

 

设计既包含函数模板又包含非模板函数的重载函数集合是困难的,因为可能会使函数的用户感到奇怪,定义

函数模板特化几乎总是比使用非模板版本更好。

C++ 模板与泛型编程

标签:

原文地址:http://www.cnblogs.com/1zhk/p/5131977.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!