Question

在学习模板参数包时，我试图编写一个聪明，简单的函数来有效地将两个或多个std::vector个容器附加在一起。

以下是两个初始解决方案。

版本1优雅但有缺陷，因为它在参数包扩展期间依赖于副作用，并且评估顺序未定义。

版本2有效，但依赖于需要两种情况的辅助函数。呸。

您能否看到是否可以提出更简单的解决方案？（为了提高效率，不应多次复制矢量数据。）

#include <vector>
#include <iostream>

// Append all elements of v2 to the end of v1.
template<typename T>
void append_to_vector(std::vector<T>& v1, const std::vector<T>& v2) {
    for (auto& e : v2) v1.push_back(e);
}

// Expand a template parameter pack for side effects.
template<typename... A> void ignore_all(const A&...) { }

// Version 1: Concatenate two or more std::vector<> containers into one.
// Nicely simple, but buggy as the order of evaluation is undefined.
template<typename T, typename... A>
std::vector<T> concat1(std::vector<T> v1, const A&... vr) {
    // Function append_to_vector() returns void, so I enclose it in (..., 1).
    ignore_all((append_to_vector(v1, vr), 1)...);
    // In fact, the evaluation order is right-to-left in gcc and MSVC.
    return v1;
}

// Version 2:
// It works but looks ugly.
template<typename T, typename... A>
void concat2_aux(std::vector<T>& v1, const std::vector<T>& v2) {
    append_to_vector(v1, v2);
}

template<typename T, typename... A>
void concat2_aux(std::vector<T>& v1, const std::vector<T>& v2, const A&... vr) {
    append_to_vector(v1, v2);
    concat2_aux(v1, vr...);
}

template<typename T, typename... A>
std::vector<T> concat2(std::vector<T> v1, const A&... vr) {
    concat2_aux(v1, vr...);
    return v1;
}

int main() {
    const std::vector<int> v1 { 1, 2, 3 };
    const std::vector<int> v2 { 4 };
    const std::vector<int> v3 { 5, 6 };
    for (int i : concat1(v1, v2, v3)) std::cerr << " " << i;
    std::cerr << "\n";          // gcc output is:  1 2 3 5 6 4
    for (int i : concat2(v1, v2, v3)) std::cerr << " " << i;
    std::cerr << "\n";          // gcc output is:  1 2 3 4 5 6
}

Answer 1

助手类型：我不喜欢使用int。

struct do_in_order { template<class T>do_in_order(T&&){}};

添加尺寸：＆＃39;

template<class V>
std::size_t sum_size( std::size_t& s, V&& v ) {return s+= v.size(); }

的毗连。返回要忽略的类型：

template<class V>
do_in_order concat_helper( V& lhs, V const& rhs ) { lhs.insert( lhs.end(), rhs.begin(), rhs.end() ); return {}; }

微优化，并允许您连接仅移动类型的向量：

template<class V>
do_in_order concat_helper( V& lhs, V && rhs ) { lhs.insert( lhs.end(), std::make_move_iterator(rhs.begin()), std::make_move_iterator(rhs.end()) ); return{}; }

实际功能。以上内容应该在详细信息命名空间中：

template< typename T, typename A, typename... Vs >
std::vector<T,A> concat( std::vector<T,A> lhs, Vs&&...vs ){
  std::size s=lhs.size();
  do_in_order _0[]={ sum_size(s,vs)..., 0 };
  lhs.reserve(s);
  do_in_order _1[]={ concat_helper( lhs, std::forward<Vs>(vs) )..., 0 };
  return std::move(lhs); // rvo blocked
}

为任何拼写错误道歉。

Answer 2

关于字符串的连接有一个相关的答案：https://stackoverflow.com/a/21806609/1190077。在这里改编，它看起来像：

template<typename T, typename... A>
std::vector<T> concat_version3(std::vector<T> v1, const A&... vr) {
    int unpack[] { (append_to_vector(v1, vr), 0)... };
    (void(unpack));
    return v1;
}

这似乎有效！

但是，模板参数包的评估顺序现在定义得很好，还是编译器做了正确的事情是偶然的呢？

Answer 3

Yakk（https://stackoverflow.com/a/23439527/1190077）的答案很有效。

这是一个精致的版本，将我的改进结合到do_in_order并删除sum_size外部函数：

// Nice syntax to allow in-order expansion of parameter packs.
struct do_in_order {
    template<typename T> do_in_order(std::initializer_list<T>&&) { }
};

namespace details {
template<typename V> void concat_helper(V& l, const V& r) {
    l.insert(l.end(), r.begin(), r.end());
}
template<class V> void concat_helper(V& l, V&& r) {
    l.insert(l.end(), std::make_move_iterator(r.begin()),
             std::make_move_iterator(r.end()));
}
} // namespace details

template<typename T, typename... A>
std::vector<T> concat(std::vector<T> v1, A&&... vr) {
    std::size_t s = v1.size();
    do_in_order { s += vr.size() ... };
    v1.reserve(s);
    do_in_order { (details::concat_helper(v1, std::forward<A>(vr)), 0)... };
    return std::move(v1);   // rvo blocked
}

用于连接std :: vector容器的可变参数模板函数

3 个答案: