C++ C++；阵列运算符开销

我记得不久前读过一些代码，这些代码允许编译器做一些工作并简化如下表达式：

// edit: yes the parameters where meant to be passed by reference
//       and maintain constness sorry !
template< typename T >
std::vector<T> operator+( const std::vector<T>& a, const std::vector<T>& b )
{
    assert( a.size() == b.size() );
    std::vector<T> o; o.reserve( a.size() );
    for( std::vector<T>::size_type i = 0; i < a.size(); ++i )
        o[i] = a[i] + b[i];
    return o;
}

// same for operator* but a[i] * b[i] instead

std::vector<double> a, b, c, d, e;

// do some initialization of the vectors

e = a * b + c * d

//编辑：是指通过引用传递的参数
//还有，对不起！
模板
标准：：向量运算符+（常数标准：：向量&a，常数标准：：向量&b）
{
断言（a.size（）==b.size（））；
std:：vector o；o.reserve（a.size（））；
对于（std:：vector:：size_type i=0；i

在通常情况下，将为每个运算符创建并分配一个新向量，而编译器将只创建一个副本，并对其执行所有操作

---

这是什么技巧？

我看这里没有问题。然而，我的水晶球告诉我，为了对向量（如

a*b+c*d

）执行组件式算术运算，您想知道两种方法中更好的方法，其中

a

，

b

，

c

，

d

是具有相同大小的向量（

std:：vector

）：

对于要执行的每个操作，循环元素，执行计算并返回结果向量。将这些运算放在向量的公式中

对于输入向量中的每个元素，计算整个表达式并将其写入一个最终生成的向量中

有两件事需要考虑：

• 性能：这里，第二个选项在前面，因为处理器不会分配不必要的临时向量
• 可重用性：显然，实现向量的算法操作并通过简单地在向量上表示目标公式来重用它们是很好的

但是，有一个很好的选项可以实现第二个看起来非常漂亮的选项：

std::vector<int> a, b, c, d, e;
// fill a, b, c, d with data

auto expression = [](int a, int b, int c, int d){ return a * b + c * d; };

assert (a.size() == b.size() && b.size() == c.size() && c.size() == d.size());
e.reserve(a.size());

for(auto _a = a.begin(), _b = b.begin(), _c = c.begin(), _d = d.begin(), _e = e.begin();
    _a != a.end();
    ++_a, ++_b, ++_c, ++_d, ++_e)
{
    *_e = expression(*_a, *_b, *_c, *_d);
}

std:：向量a，b，c，d，e；
//用数据填写a、b、c、d
自动表达式=[]（inta，intb，intc，intd）{返回a*b+c*d；}；
断言（a.size（）==b.size（）&&b.size（）==c.size（）&&c.size（）==d.size（））；
e、 储备（a.size（））；
对于（auto _a=a.begin（），_b=b.begin（），_c=c.begin（），_d=d.begin（），_e=e.begin（）；
_a！=a.end（）；
++_a、 ++b、++c、++d、++e）
{
*_e=表达式（*u a，*_b，*_c，*_d）；
}

通过这种方式，您可以将表达式与逻辑分离以对其求值：

void componentWise4(std::function<int(int,int,int,int)> f,
                    const std::vector<int> & a,
                    const std::vector<int> & b,
                    const std::vector<int> & c,
                    const std::vector<int> & d,
                    std::vector<int> & result)
{
    assert (a.size() == b.size() && b.size() == c.size() && c.size() == d.size());
    result.reserve(a.size());

    for(auto _a = a.begin(), _b = b.begin(), _c = c.begin(), _d = d.begin(), _result = result.begin();
        _a != a.end();
        ++_a, ++_b, ++_c, ++_d, ++_result)
    {
        *_result = expression(*_a, *_b, *_c, *_d);
    }
}

void组件4（标准：：函数f，
常数std：：向量&a，
const std：：vector&b，
常量标准：：向量和c，
const std：：vector&d，
标准：向量和结果）
{
断言（a.size（）==b.size（）&&b.size（）==c.size（）&&c.size（）==d.size（））；
结果：保留（a.大小（））；
对于（auto _a=a.begin（），_b=b.begin（），_c=c.begin（），_d=d.begin（），_result=result.begin（）；
_a！=a.end（）；
++_a、 ++b、++c、++d、++结果）
{
*_结果=表达式（*u a、*\u b、*\u c、*\u d）；
}
}

这就是所谓的：

std::vector<int> a, b, c, d, e;
// fill a, b, c, d with data

componentWise4([](int a, int b, int c, int d){ return a * b + c * d; },
               a, b, c, d, e);

std:：向量a，b，c，d，e；
//用数据填写a、b、c、d
组件4（[]（inta，intb，intc，intd）{返回a*b+c*d；}，
a、 b、c、d、e）；

---

我确信这个“表达式计算器”可以使用C++11的新特性“可变模板”进行扩展，以支持表达式中任意数量的参数，甚至支持不同类型的参数。我无法让它工作（可变模板的事情），你可以尝试在这里完成我的尝试：（我是可变模板的新手，所以我不知道语法）。

我在这里没有看到问题。然而，我的水晶球告诉我，为了对向量（如

a*b+c*d

）执行组件式算术运算，您想知道两种方法中更好的方法，其中

a

，

b

，

c

，

d

是具有相同大小的向量（

std:：vector

）：

对于要执行的每个操作，循环元素，执行计算并返回结果向量。将这些运算放在向量的公式中

对于输入向量中的每个元素，计算整个表达式并将其写入一个最终生成的向量中

有两件事需要考虑：

• 性能：这里，第二个选项在前面，因为处理器不会分配不必要的临时向量
• 可重用性：显然，实现向量的算法操作并通过简单地在向量上表示目标公式来重用它们是很好的

但是，有一个很好的选项可以实现第二个看起来非常漂亮的选项：

std::vector<int> a, b, c, d, e;
// fill a, b, c, d with data

auto expression = [](int a, int b, int c, int d){ return a * b + c * d; };

assert (a.size() == b.size() && b.size() == c.size() && c.size() == d.size());
e.reserve(a.size());

for(auto _a = a.begin(), _b = b.begin(), _c = c.begin(), _d = d.begin(), _e = e.begin();
    _a != a.end();
    ++_a, ++_b, ++_c, ++_d, ++_e)
{
    *_e = expression(*_a, *_b, *_c, *_d);
}

std:：向量a，b，c，d，e；
//用数据填写a、b、c、d
自动表达式=[]（inta，intb，intc，intd）{返回a*b+c*d；}；
断言（a.size（）==b.size（）&&b.size（）==c.size（）&&c.size（）==d.size（））；
e、 储备（a.size（））；
对于（auto _a=a.begin（），_b=b.begin（），_c=c.begin（），_d=d.begin（），_e=e.begin（）；
_a！=a.end（）；
++_a、 ++b、++c、++d、++e）
{
*_e=表达式（*u a，*_b，*_c，*_d）；
}

通过这种方式，您可以将表达式与逻辑分离以对其求值：

void componentWise4(std::function<int(int,int,int,int)> f,
                    const std::vector<int> & a,
                    const std::vector<int> & b,
                    const std::vector<int> & c,
                    const std::vector<int> & d,
                    std::vector<int> & result)
{
    assert (a.size() == b.size() && b.size() == c.size() && c.size() == d.size());
    result.reserve(a.size());

    for(auto _a = a.begin(), _b = b.begin(), _c = c.begin(), _d = d.begin(), _result = result.begin();
        _a != a.end();
        ++_a, ++_b, ++_c, ++_d, ++_result)
    {
        *_result = expression(*_a, *_b, *_c, *_d);
    }
}

void组件4（标准：：函数f，
常数std：：向量&a，
const std：：vector&b，
常量标准：：向量和c，
const std：：vector&d，
标准：向量和结果）
{
断言（a.size（）==b.size（）&&b.size（）==c.size（）&&c.size（）==d.size（））；
结果：保留（a.大小（））；
对于（auto _a=a.begin（），_b=b.begin（），_c=c.begin（），_d=d.begin（），_result=result.begin（）；
_a！=a.end（）；
++_a、 ++b、++c、++d、++结果）
{
*_结果=表达式（*u a、*\u b、*\u c、*\u d）；
}
}

那是什么呢