c++ - vector 的算术运算

Question

假设我想为 std::vector 提供逐元素算术运算 operator+= 和 operator+ 以逐元素添加 vector 条目.通常，我看到 operator+ 是根据 operator+= 实现的，如下所示:

#include <algorithm>
#include <vector>

template<class Type>
std::vector<Type> & operator+=(std::vector<Type> &x, const std::vector<Type> &y) {
    // Checks for equal size of x and y omitted here...
    std::transform(std::begin(x), std::end(x), std::begin(y), std::begin(x), std::plus<Type>());
    return x;
}

template<class Type>
std::vector<Type> operator+(std::vector<Type> x, const std::vector<Type> &y) {
    // Checks for equal size of x and y omitted here...
    return x += y;
}

int main() {
    std::vector<double> v0{1.0, 2.0, 3.0};
    auto v1 = v0;

    auto v2 = v0;
    v2 += v0; // yields [2, 4, 6]

    auto v3 = v0 + v1; // yields [2, 4, 6]

    return 0;
}

在性能方面，我猜

template<class Type>
std::vector<Type> operator+(const std::vector<Type> &x, const std::vector<Type> &y) {
    // Checks for equal size of x and y omitted here...
    std::vector<Type> result;
    result.reserve(x.size());
    std::transform(std::begin(x), std::end(x), std::begin(y), std::back_inserter(result), std::plus<Type>());
    return result;
}

更高效，因为它避免在进入函数时初始化第一个参数的拷贝，而是将结果直接放入未初始化的内存块中。实现第二个版本真的值得吗？还是我可以假定编译器无论如何都会进行优化？另外，我认为第二种选择比第一种更不通用。想象一下类似的东西

#include <array>
#include <type_traits>

template<class Container, class Enable = void>
struct IsSequenceContainer: public std::false_type {
};

template<>
template<class Type, std::size_t size>
struct IsSequenceContainer<std::array<Type, size> >: public std::true_type {
};

template<>
template<class Type, class Allocator>
struct IsSequenceContainer<std::vector<Type, Allocator> >: public std::true_type {
};

// Use the following operations for std::array and std::vector
template<class Container>
typename std::enable_if<IsSequenceContainer<Container>::value, Container>::type operator+(Container x, const Container &y) {
    return x += y;
}

Answer 1

对于所有与性能相关的事情:分析程序，看看会发生什么。

我的猜测是编译器不会完全优化代码——而且它可能永远不会重要。唯一确定的方法就是尝试一下。

根据 += 实现 + 的优点是这两个操作是等价的。这使得错误发生的可能性降低。在放弃此优势之前，您应该确保您的优化是必要的。 C++ 的习语通常有充分的理由成为习语。