表达式模板 (C++学习)

分类： C/C++ Qt2011-08-17 00:53 4043人阅读 评论(7) 收藏 举报

c++concatenationvectortemplatesclassarrays

目录(?)[+]

Qt从4.6开始，引入了一个QStringBuilder的内部类

• 在QString的Manual中，你可以找到关于它的简单介绍

• 在 String concatenation with QStringBuilder有详细介绍

这个类主要使用了一个被称为表达式模板(Expression templates)的东西。

表达式模板？

表达式模板是由Todd Veldhuizen在1995年6月在一篇文章中给出的。

表达式模板是一种C++模板元编程(template metaprogramming)技术。典型情况下，表达式模板自身代表一种操作，模板参数代表该操作的操作数。模板表达式可将子表达式的计算推迟，这样有利于优化(特别是减少临时变量的使用)。表达式模板也可以作为参数传递给一个函数。

例子

比如：我们定义了数组类 Array

class Array{public:    double & operator[](size_t i) { return _data[i]; }    double operator[](size_t i) const { return _data[i]; }    size_t size() const { return _data.size(); }    Array(size_t n) : _data(n) {}private:    std::vector<double> _data;};

但是想实现下面的效果：

void f(const Array & a1, const Array & a2){    Array b = 10 * (a1 - 2 * a2);    //...}

如何做呢？容易想到：重载 operator* 和 operator- 操作符

Array operator*(double, const Array&);Array operator-(const Array&, const Array&);...

但这样一来，会产生很多临时的Array对象，让人比较难以接受 ...

而表达式模板，允许你写上面的代码，实现的却是下面的效果：

for (size_t i=0; i<a1.size(); ++i) {    b[i] = 10 * (a1[i] - 2 * a2[i]);}

很神奇的东西，可是，它怎么实现的呢？

实现

我们看看 wikipedia 中的例子(简化后)：

• 定义一个基类：ArrayExpression

• 我们的 Array 派生自 ArrayExpression

• 创建派生类 ArrayDifference 和 ArrayScaled，分别代表 a1 - a2 和 10 * a1 这种表达式

这样一来，前面表达式中出现的子表达式都可以用 ArrayExpression 来表示了，然后重载了 operator* 和 operator- 操作符，使得： 10 * a1 和 a1 - a2 的结果分别是 ArrayScaled 和ArrayDifference

• 需要的头文件，我们的Array内部用std::vector存储数据

#include <iostream>#include <vector>

• 模板基类

template <typename E>class ArrayExpression{public:    operator E const&() const { return static_cast<const E&>(*this); }};

• 我们的Array类

class Array : public ArrayExpression<Array>{public:    double & operator[](size_t i) { return _data[i]; }    double operator[](size_t i) const { return _data[i]; }    size_t size() const { return _data.size(); }    Array(size_t n) : _data(n) {}    template <typename E>    Array(ArrayExpression<E> const& vec) {        E const& v = vec;        _data.resize(v.size());        for (size_t i = 0; i != v.size(); ++i) {            _data[i] = v[i];        }    }private:    std::vector<double> _data;};

• ArrayDifference 类，参数是任意两个ArrayExpression

template <typename E1, typename E2>class ArrayDifference : public ArrayExpression<ArrayDifference<E1, E2> >{public:    ArrayDifference(ArrayExpression<E1> const& u, ArrayExpression<E2> const& v) : _u(u), _v(v) { }    size_t size() const { return _v.size(); }    double operator[](size_t i) const { return _u[i] - _v[i]; }private:    E1 const& _u;    E2 const& _v;};

• ArrayScaled 类，参数是一个double型，一个ArrayExpression

template <typename E>class ArrayScaled : public ArrayExpression<ArrayScaled<E> >{public:    ArrayScaled(double alpha, ArrayExpression<E> const& v) : _alpha(alpha), _v(v) {}    size_t size() const { return _v.size(); }    double operator[](size_t i) const { return _alpha * _v[i]; }private:    double _alpha;     E const& _v;};

• 是时候重载操作符了：

template <typename E1, typename E2>ArrayDifference<E1,E2> const operator-(ArrayExpression<E1> const& u, ArrayExpression<E2> const& v){    return ArrayDifference<E1,E2>(u,v);}template <typename E>ArrayScaled<E> const operator*(double alpha, ArrayExpression<E> const& v){    return ArrayScaled<E>(alpha,v);} 

• 然后写个程序测试一下：

int main(){    Array a1(10), a2(10);    for (int i=0; i<10; ++i) {        a1[i] = i*i;        a2[i] = i;    }    Array a3 = 10*(a1-2*a2);    for (int i=0; i<10; ++i){        std::cout<<a3[i]<<" ";    }    return 0;}

我们可以通过typeid来看一下表达式的类型：

std::cout<<typeid(10*(a1-2*a2)).name();

MSVC 给出的消息很容易看：

class ArrayScaled<class ArrayDifference<class Array,class ArrayScaled<class Array> > >

GCC给出的比较难看懂

11ArrayScaledI15ArrayDifferenceI5ArrayS_IS1_EEE0

总结：

表达式模板的特点如下

1.表达式模板提供运算接口 operater [] ，且每个实现类在运算过程中均不进行值传递，体现在实现类的成员变量是引用类型。这样减少了临时对象的 开销。

2.表达式模板与 运算的实体类 可相互转换（用=相互初始化），体现在

     1）继承自同一父类，该父类有一模板参数，用于接收他的子类类型。 继承自同一父类实现了表达式类型和实体类型之间的交互。而提供 operater E() 这个方法实现了：一个子类从另一个子类转换的能力。

template <typename E>class ArrayExpression{public:    operator E const&() const { return static_cast<const E&>(*this); }};

   2）实体类提供了一个接收其他子类类型模板参数的构造函数，可以调用表达式模板类型的operater [] 接口，完成自己成员对象的初始化。

template <typename E>    Array(ArrayExpression<E> const& vec) {        E const& v = vec;        _data.resize(v.size());        for (size_t i = 0; i != v.size(); ++i) {            _data[i] = v[i];        }    }

这里的v，是表达式相互推导之后的最终类型，提供了推导之后的表达式类型的 operater [] 接口，将表达式的[] 转化成 数据成员的[]。而在构造函数中的for自动实现了为成员便量的每一元素赋值。