WH>int size=10000;
WH>array_t<float> a(size);
WH>array_t<float> b(size);
WH>array_t<float> c(size);
WH>array_t<float> d(size);
WH>array_t<float> e(size);
WH>array_t<float> f(size);
WH>float x;
WH>float y;
WH>float z;
WH>//тут инициализация
WH>f*=(a/x+5)*b-(y*c-d/5)/e-z;
WH>//что эквивалентно (без перегрузки операторов)
WH>for(int i=0;i<size;++i)
WH>    f.at(i)*=(a.at(i)/x+5)*b.at(i)-(y*c.at(i)-d.at(i)/5)/e.at(i)-z;
WH>

некоторое действие, которое выглядит как сложение, но делает то, что знаю только я!

WH>string s1;
WH>string s2;
WH>string s3;
WH>string s4;
WH>string s5;
WH>//тут инициализация
WH>string s6=s1+s2+s3+s4+s5;
WH>//что эквивалентно (без перегрузки операторов)
WH>string s6=string_cat(s1, string_cat(s2, string_cat(s3, string_cat(s4, s5))));
WH>

WH>vector v1;
WH>vector v2;
WH>matrix m;
WH>//тут инициализация
WH>vector v3=(v1-v2)*m;
WH>//что эквивалентно (без перегрузки операторов)
WH>vector v2=mul_vector_matrix(sub_vector_vector(v1, v2), m);
WH>

Для типа array_t перегружены все арифметические операторы так что запись вида arr1*arr2 трактуется как поэлементное умножение массивов. А запись вида const*arr трактуется как поэлементное умножение массива на константу.

K_O> Но почему язык позволяет таким индивидуумам так хулиганить?

K_O>А что, для того, чтобы проинициализировать такой супер краткий шаблон надо "гору кода" писать? Так толку тогда с таких кратких выражений...

f*=(a/x+5)*b-(y*c-d/5)/e-z;
или
MultiplyAssignItemByItem(f, SubtractItemByScalar(SubtractItemByItem(MultiplyItemByItem(AddItemByScalar(DivideItemByScalar(a, x), 5), b)), DivideItemByItem(SubstractItemByItem(MSI(y, c), DivideItemByScalar(d, 5)), e), z));

    MultiplyAssignItemByItem
        (f
        ,SubtractItemByScalar
            (SubtractItemByItem
                (MultiplyItemByItem
                    (AddItemByScalar
                        (DivideItemByScalar
                            (a
                            ,x
                            )
                        ,5
                        )
                    ,b
                    )
                ,DivideItemByItem
                    (SubstractItemByItem
                        (MultiplyScalarByItem
                            (y
                            ,c
                            )
                        ,DivideItemByScalar
                            (d
                            ,5
                            )
                        ,e
                        )
                    ,z
                    )
                )
            )
        );

f*=(a/x+5)*b-(y*c-d/5)/e-z;

struct calculator : public grammar<calculator>
{
    template <typename ScannerT>
    struct definition
    {
        definition(calculator const& /*self*/)
        {
            expression
                =   term
                    >> *(   ('+' >> term)[&do_add]
                        |   ('-' >> term)[&do_subt]
                        )
                ;

            term
                =   factor
                    >> *(   ('*' >> factor)[&do_mult]
                        |   ('/' >> factor)[&do_div]
                        )
                ;

            factor
                =   lexeme_d[(+digit_p)[&do_int]]
                |   '(' >> expression >> ')'
                |   ('-' >> factor)[&do_neg]
                |   ('+' >> factor)
                ;
        }

        rule<ScannerT> expression, term, factor;

        rule<ScannerT> const&
        start() const { return expression; }
    };
};

namespace vectors
{
    template<class T>
    struct vector3
    {
        vector3()
            :x()
            ,y()
            ,z()
        {}
        vector3(T _x, T _y, T _z)
            :x(_x)
            ,y(_y)
            ,z(_z)
        {}
        T x;
        T y;
        T z;
        vector3<T>& operator+=(vector3<T> const& that)
        {
            x+=that.x;
            y+=that.y;
            z+=that.z;
            return *this;
        }
    };
    template<class T>
    vector3<T> operator+(vector3<T> const& l, vector3<T> const& r)
    {
        return vector3<T>(l)+=r;
    }
    template<class T>
    T dot(vector3<T> const& l, vector3<T> const& r)
    {
        return l.x*r.x+l.y*r.y+l.z*r.z;
    }
    template<class T>
    vector3<T> cross(vector3<T> const& l, vector3<T> const& r)
    {
        return vector3<T>
            (l.y*r.z-l.z*r.y
            ,l.z*r.x-l.x*r.z
            ,l.x*r.y-l.y*r.x
            );
    }
}
int main()
{
    vectors::vector3<float> v1;
    vectors::vector3<float> v2;
    vectors::vector3<float> v3;
    v1=v2+v3;
    float f=dot(v1+v2, v2+cross(v3, v1));
}

int size=10000;
array_t<float> a(size);
array_t<float> b(size);
array_t<float> c(size);
array_t<float> d(size);
array_t<float> e(size);
array_t<float> f(size);
float x;
float y;
float z;
//тут инициализация
f*=(a/x+5)*b-(y*c-d/5)/e-z;//Этот велосипед нужен только ради такой записи
//что эквивалентно (без перегрузки операторов)
for(int i=0;i<size;++i)
    f.at(i)*=(a.at(i)/x+5)*b.at(i)-(y*c.at(i)-d.at(i)/5)/e.at(i)-z;

WH>

WH>f*=(a/x+5)*b-(y*c-d/5)/e-z;
WH>или
WH>MultiplyAssignItemByItem(f, SubtractItemByScalar(SubtractItemByItem(MultiplyItemByItem(AddItemByScalar(DivideItemByScalar(a, x), 5), b)), DivideItemByItem(SubstractItemByItem(MSI(y, c), DivideItemByScalar(d, 5)), e), z));
WH>

WH>Это не то что прочитать... это написать трудно

for (int i = 0; i < array_size; i++)
  f[i] *= (a[i] / x + 5) * b[i] - (y * c[i] - d[i] / 5) / e[i] - z;

WH>   Skipped.
WH>

WH>EBNF грамматика прямо на С++...

WH>Зачем?