我正在尝试围绕表达式模板进行思考。在wikipedia article 中,给出了一个示例,其中表达式模板VecSum
存储对其两个操作数的const 引用。AVec
是一个表达式模板,它包含一个std::vector<double>
. 我将首先提出我的问题,然后对下面的示例进行完整的概述。
我可以重用使用 const 对临时对象的引用的表达式吗?如果没有,我将如何实现轻量级、可重复使用的表达式模板?
对于三个Vec
, a
,b
和c
表达式a+b+c
是类型
VecSum<VecSum<Vec, Vec>, Vec>
如果我理解正确,内部VecSum
是临时的,外部VecSum
存储对内部的 const 引用VecSum
。我相信在表达式被评估之前,内部VecSum
临时的生命周期是有保证的。正确的?这是否意味着在没有创建悬空引用的危险的情况下不能重用表达式?a+b+c
auto expr = a + b + c;
Vec v1 = expr; // ok
Vec v2 = expr; // not ok!
如果是这样,如何修改此示例,以便
- 表达式是可重用的
- 表达式不存储其操作数的副本(至少在不需要的情况下)?
完整代码示例
为了完整起见 - 如果同时更新了 wikipedia 文章,让我在这里重复示例代码并给出一个示例main
,我相信它会创建一个悬空引用。
#include <cassert>
#include <vector>
template <typename E>
class VecExpression {
public:
double operator[](size_t i) const
{
// Delegation to the actual expression type. This avoids dynamic polymorphism (a.k.a. virtual functions in C++)
return static_cast<E const&>(*this)[i];
}
size_t size() const { return static_cast<E const&>(*this).size(); }
};
class Vec : public VecExpression<Vec> {
std::vector<double> elems;
public:
double operator[](size_t i) const { return elems[i]; }
double &operator[](size_t i) { return elems[i]; }
size_t size() const { return elems.size(); }
Vec(size_t n) : elems(n) {}
// construct vector using initializer list
Vec(std::initializer_list<double> init) : elems(init) {}
// A Vec can be constructed from any VecExpression, forcing its evaluation.
template <typename E>
Vec(VecExpression<E> const& expr) : elems(expr.size()) {
for (size_t i = 0; i != expr.size(); ++i) {
elems[i] = expr[i];
}
}
};
template <typename E1, typename E2>
class VecSum : public VecExpression<VecSum<E1, E2> > {
E1 const& _u;
E2 const& _v;
public:
VecSum(E1 const& u, E2 const& v) : _u(u), _v(v) {
assert(u.size() == v.size());
}
double operator[](size_t i) const { return _u[i] + _v[i]; }
size_t size() const { return _v.size(); }
};
template <typename E1, typename E2>
VecSum<E1, E2>
operator+(VecExpression<E1> const& u, VecExpression<E2> const& v) {
return VecSum<E1, E2>(*static_cast<const E1*>(&u), *static_cast<const E2*>(&v));
}
int main() {
Vec v0 = {23.4,12.5,144.56,90.56};
Vec v1 = {67.12,34.8,90.34,89.30};
Vec v2 = {34.90,111.9,45.12,90.5};
auto expr = v0 + v1 + v2;
Vec v1 = expr; // ok
Vec v2 = expr; // not ok!
}
编辑:
我刚刚意识到这可能是这个问题的重复。然而,这两个问题的答案非常不同,而且都很有用。