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

晨曦之光 发布于 2012/05/08 10:15
阅读 142
收藏 0

Qt从4.6开始,引入了一个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

参考




原文链接:http://blog.csdn.net/dbzhang800/article/details/6693454
加载中
返回顶部
顶部