C++ vector that uses expression templates technique to increase performance of mathematical expressions

Generally speaking, it's pretty good. However, there are still a few things that I would have done differently:

• typedef becomes kind of ugly now that we have type aliases. Always using type aliases generally tends to produce more readable and more consistent code:

  using size_type = typename std::vector<T>::size_type; 

• Loop only when you have to. In your std::initializer_list constructor, you don't need to loop; you can use std::vector's constructor taking a pair of iterators instead:

  Vec(const std::initializer_list<T>& elements): data(std::begin(elements), std::end(elements)) { } 

• By the way std::initializer_list tends to be no more than a pair of pointers. You can take it directly by value instead of taking it by const reference.

• In operator+ and operator-, I would have placed the return type into the function signature and then used the list initialization syntax in the return statement:

  template<typename T1, typename T2> auto operator+(const T1& t1, const T2& t2) -> VecSum<T1, T2> { return { t1, t2 }; } 

  Whether it is better or not is debatable but when the return type is fixed, rather meaningful and arguably simple, I prefer to expose it in the signature.

The problem with this library now is that the operators are capture-anything. (This also applies to the constructor). Thus they can accidentally apply to the things they are not supposed to. You have to restrict the types of arguments somehow.

For example, the code

Vec<int> v5(5); 

does not compile, because the compiler selects the constructor

template<typename VecOperation> Vec(const VecOperation& vo) 

because it is a better match (the other constructor would require conversion from int to size_t).

You can either use metaprogramming (SFINAE) to restrict your template functions, or inherit Vec and all your operations from some CRTP base class, like VecBase<Derived>. (this is what Eigen does, and this library is a good example of expression template usage, although may be too complex for easily understand).

By the way, some implementations of std::valarray use expression templates as well.