表达式模板 (C++学习)
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
参考
-
http://shoddykid.blogspot.com/2008/07/expression-templates-demystified.html
-
http://cplusplus.wikidot.com/cn:expression-templates
-
http://www10.informatik.uni-erlangen.de/~pflaum/pflaum/ProSeminar/exprtmpl.html
-
http://stackoverflow.com/questions/2526862/tutorials-and-introductions-to-c-expression-templates
-
http://stackoverflow.com/questions/2598579/c-expression-templates
-
http://en.wikipedia.org/wiki/Expression_templates
-
http://labs.qt.nokia.com/2011/06/13/string-concatenation-with-qstringbuilder/