1

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

// 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

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

这是什么技术？

4

3 回答 3

3

正如@Agnew 很早就提到的那样，您描述的技术是表达式模板。

这通常使用向量1的数学概念来完成，而不是 a std::vector。大致的笔画是：

  1. 不要对向量进行数学运算返回结果。相反，让他们返回一个代表最终需要完成的操作 的代理对象。a * b可以返回一个“乘法代理”对象，该对象仅包含对应该相乘的两个向量的 const 引用。

  2. 也为这些代理编写数学运算，允许它们链接在一起，所以a * b + c * d变成了(TempMulProxy) + (TempMulProxy)，(TempAddProxy)所有这些都不需要做任何数学运算或复制任何向量。

  3. 编写一个赋值运算符，将您的代理对象作为右侧对象。该运算符可以查看整个表达式a * b + c * d并在您的向量上有效地执行该操作，同时知道目的地。所有这些都无需创建多个临时矢量对象。

1或矩阵或四元数等... *

于 2013-02-07T16:52:05.517 回答
1

我在这里看不到问题。但是，我的水晶球告诉我，您想知道您想出的两种方法中更好的方法，以便对向量执​​行逐分量算术运算，例如a * b + c * dwhere a, b, c, dare vectors ( std::vector<T>) 具有相同大小：

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

  2. 对于输入向量中的每个元素，计算整个表达式并将其写入一个最终结果向量。

有两点需要考虑：

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

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

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);
}

这样，您可以将表达式与逻辑分开来评估它：

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);
    }
}

然后这样调用：

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);

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

于 2013-02-07T16:19:23.163 回答
1

你想要的是“The C++ Programming Language”。Bjarne Stroustrup 在22.4.7 Temporaries, Copying, and Loops [num.matrix] 中的第三版。读这本书总是一个好主意。

如果你没有它，基本上我们有两个选择：

第一：我们写了一组函数，用于直接计算一些最期望的组合（例如mul_add_and_assign(&U,&M,&V,&W)来计算U =M*V+W）并引导用户选择自己用什么函数他最方便。

第二：我们可以引入一些辅助类（例如VxV，VplusV等），它们只保留对每个操作的参数的引用，并定义一个运算符转换为vector。现在我们创建运算符的重载，+它*通过引用获取两个向量并返回相应类型的对象。我们可以创建该类型的类VxVplusVxV来计算更复杂的操作。现在我们可以重载operator=到VxVplusVxV一个vector. 在最后一次重载中，我们使用对保存在辅助类对象中的参数的引用进行了所有计算，没有或创建了最少的临时向量。

于 2013-02-07T17:56:34.693 回答