expression-templates

I understand that doing something like the following: auto&& x = Matrix1() + Matrix2() + Matrix3(); std::cout << x(2,3) << std::endl; Will cause a silent runtime error if the matrix operations use expression templates (such as boost::ublas ). Is there any way of designing expression templates to prevent the compiler from compiling such code that may result in the use of expired temporaries at runtime? (I've attempted unsuccessfully to work around this issue, the attempt is here ) Is there any way of designing expression templates to prevent the compiler from compiling such code that may result

I incurred in a compiler dependent issue with the following code (stored in crtp.cc): #include <vector> #include <cassert> #include <iostream> template < class Derived > class AlgebraicVectorExpression { public: typedef std::vector<double>::size_type SizeType; typedef std::vector<double>::value_type ValueType; typedef std::vector<double>::reference ReferenceType; SizeType size() const { return static_cast<const Derived&>(*this).size(); } ValueType operator[](SizeType ii) const { return static_cast<const Derived&>(*this)[ii]; } operator Derived&() { return static_cast<Derived&>(*this); }

I would like to use the Eigen matrix library as the linear algebra engine in my program. Eigen uses expression templates to implement lazy evaluation and to simplify loops and calculations. For example: #include<Eigen/Core> int main() { int size = 40; // VectorXf is a vector of floats, with dynamic size. Eigen::VectorXf u(size), v(size), w(size), z(size); u = 2*v + w + 0.2*z; } Since Eigen uses expression templates, code like u = 2*v + w + 0.2*z; In the above mentioned sample reduces to a single loop of length 10 (not 40, the floats are put into regiser by chunks of 4) without creating a

in C++ Template Metaprogramming : Concepts, Tools, and Techniques from Boost and Beyond ... One drawback of expression templates is that they tend to encourage writing large, complicated expressions, because evaluation is only delayed until the assignment operator is invoked. If a programmer wants to reuse some intermediate result without evaluating it early, she may be forced to declare a complicated type like: Expression< Expression<Array,plus,Array>, plus, Expression<Array,minus,Array> > intermediate = a + b + (c - d); (or worse). Notice how this type not only exactly and redundantly

Let's look at one particular benefit of expression templates: ETs can be used to avoid vector-sized temporaries in memory which occur in overloaded operators like: template<typename T> std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b) { std::vector<T> tmp; // vector-sized temporary for_each(...); return tmp; } In C++11 the return statement of this function applies move semantics. No copy of the vector. That's a win. However, if I look at a simple expression like d = a + b + c; I see that the above function gets called twice (for both operator+ ) while the final