关于C++：将向量附加到向量中

Appending a vector to a vector

本问题已经有最佳答案，请猛点这里访问。

假设我有两个标准向量：

1 2	vector<int> a; vector<int> b;

假设两者都有大约30个元素。

如何将向量b添加到向量a的末尾？

最糟糕的方法是通过b迭代并通过vector::push_back()添加每个元素，尽管我不想这样做！

相关讨论

我想每个人都会用迭代器发布答案。我从来没有弄清楚为什么vector没有op+=()或append()函数。
@Neil因为insert就足够了？
@安德烈亚斯，对std：：string来说，这是不可能的吗？当然，insert()已经足够了，但在您的答案中，它远不是显而易见的，实际发生的是一个向量被附加到另一个向量上。A+=B使这变得透明。
@安德烈亚斯：从性能上讲，它可能足够好用，但它不容易阅读。imo a.append(b)甚至a+=b比a.insert(a.end(), b.begin(), b.end())更能捕捉到意图。
也许有一天有人会将append函数添加到向量模板中：)
@许多人认为Neil std::string是一个惊人的设计失败。不需要在vector中添加append函数，如果您真的需要它，您可以将自己的版本作为一个自由函数来编写。
@尼尔引用赫伯·萨特和安德烈·亚历山德里斯库的话："埃多克司(EDOCX1)(7)是一个同样臭名昭著的整体类设计的例子……"
@安德烈亚斯，我认为你指的是"胖接口"问题。有些类应该有胖接口，imho字符串就是其中之一——我发现std：：string可以在外部使用，不管纯粹主义者怎么说。我只是觉得Vector可以增加一些权重，让用户的生活更轻松，让代码的读者更清楚。
同样的问题列表：stackoverflow.com/questions/2349098/c-linked-list-behavior/&hellip；&zwnj；&8203；，有趣的是，同样的答案是：—)
@尼尔：我在std::vector::append()上和你在一起，在+=上和你在一起，直到我看到stackoverflow.com/questions/2552839/2553683 2553683。
在我看来，operator+()的问题在于它暗示(尽管很微妙)一个O(1)操作。是的，弦乐有它，但弦乐也有滥用operator+()的著名陷阱。这是个问题，我喜欢C++使你编写低效代码变得更加困难的方法。
我觉得C++中的很多东西都可以在命名和使用方便方面使用一些TLC。我完全赞成一个append()函数，即使它不保存太多的输入，在读取代码时也会更加清晰。
如何进行Perly并重写operator.以附加？
@约翰·埃多克斯1〔12〕不能被推翻。
@这里的设计意图是通用的(也就是说，数据类型独立)。如果支持+则可能使用为数据类型定义的+来实现。这将对一种可以与向量一起使用的数据类型施加很大的限制。
@Andreasbrinck程序集对于任何编程任务都是"足够的"；它也非常快速。这并不意味着它易于使用，甚至可读。

1	a.insert(a.end(), b.begin(), b.end());

或

1	a.insert(std::end(a), std::begin(b), std::end(b));

第二种变体是一种更通用的解决方案，因为b也可以是一个数组。但是，它需要C++ 11。

相关讨论

我需要在insert之前用reserve吗？
@不需要Violetgiraffe储备，但可能是可取的。如果你反复插入一个向量，知道它的最终大小，并且这个向量的大小很大，那么使用reserve是明智的。否则，我会让stl根据需要增加向量。
如果尝试将向量附加到其自身，则此解决方案失败。它以正确的大小生成向量，但添加空元素而不是原始元素。只有当您用v.reserve(v.size()*2)预先填充它时，它才开始工作；(但它可能取决于stl实现)
@Sergey我认为该标准特别指出，给予insert的迭代器不能与接收对象的元素在同一范围内，所以我认为从技术上讲，它是ub。
@比这更糟的是，您为vector范围的末尾传递的end迭代器被插入无效，即使您首先保留(因为它在插入点处或之后，这会使插入无效)。调试模式std::vector可能会遇到这种情况(大多数版本不会，而且只会工作)。
@templatetypedef你有关于这个的引文吗？我所知道的解决方法可能仍然会在这里遇到麻烦。
在我的草案C++ 14标准中，YAKK表100(序列容器要求)列出了调用EDOCX1 6的前提条件："i和j不是迭代器进入A"。
@moodboom如果不是最后一次插入，则shell在单个插入之前不使用reserve。在大多数实现中，vector：：reserve不会以指数形式增长向量缓冲区，它会将缓冲区大小设置为您保留的精确元素数量。例如，一系列调用"reserve(size()+1)"具有二次复杂性
@Zab如果你说多次调用Reserve是有问题的做法，我同意，你应该让库根据需要增加向量。这就是为什么我说如果你知道想要的最终尺寸就使用它(一次)。但你是这么说的吗？-)
@谢尔盖，你真的不知道这件事吗？你能解释一下吗："是乌兰巴托。"—意思是
@serup"ub"指的是未定义的行为。en.cppreference.com/w/cpp/language/ub(英文)
在手机上，不小心投了反对票。直到后来锁上才意识到。我可以取消这次投票吗？

1	std::copy (b.begin(), b.end(), std::back_inserter(a));

这可用于向量A中的项没有赋值运算符(例如const成员)的情况。

在所有其他情况下，与上述插入解决方案相比，此解决方案无效。

相关讨论

当说"编译器可以保留"时，为什么要依赖它？那么自动检测移动语义呢？那么，重复使用begins和ends的容器名称会怎么样？

你不想要更简单的东西吗？

(向下滚动到main以显示冲压线)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

#include <type_traits>
#include <vector>
#include <iterator>
#include <iostream>

template<typename C,typename=void> struct can_reserve: std::false_type {};

template<typename T, typename A>
struct can_reserve<std::vector<T,A>,void>:
std::true_type
{};

template<int n> struct secret_enum { enum class type {}; };
template<int n>
using SecretEnum = typename secret_enum<n>::type;

template<bool b, int override_num=1>
using EnableFuncIf = typename std::enable_if< b, SecretEnum<override_num> >::type;
template<bool b, int override_num=1>
using DisableFuncIf = EnableFuncIf< !b, -override_num >;

template<typename C, EnableFuncIf< can_reserve<C>::value >... >
void try_reserve( C& c, std::size_t n ) {
c.reserve(n);
}
template<typename C, DisableFuncIf< can_reserve<C>::value >... >
void try_reserve( C& c, std::size_t ) { } // do nothing

template<typename C,typename=void>
struct has_size_method:std::false_type {};
template<typename C>
struct has_size_method<C, typename std::enable_if<std::is_same<
decltype( std::declval<C>().size() ),
decltype( std::declval<C>().size() )
>::value>::type>:std::true_type {};

namespace adl_aux {
using std::begin; using std::end;
template<typename C>
auto adl_begin(C&&c)->decltype( begin(std::forward<C>(c)) );
template<typename C>
auto adl_end(C&&c)->decltype( end(std::forward<C>(c)) );
}
template<typename C>
struct iterable_traits {
typedef decltype( adl_aux::adl_begin(std::declval<C&>()) ) iterator;
typedef decltype( adl_aux::adl_begin(std::declval<C const&>()) ) const_iterator;
};
template<typename C> using Iterator = typename iterable_traits<C>::iterator;
template<typename C> using ConstIterator = typename iterable_traits<C>::const_iterator;
template<typename I> using IteratorCategory = typename std::iterator_traits::iterator_category;

template<typename C, EnableFuncIf< has_size_method<C>::value, 1>... >
std::size_t size_at_least( C&& c ) {
return c.size();
}

template<typename C, EnableFuncIf< !has_size_method<C>::value &&
std::is_base_of< std::random_access_iterator_tag, IteratorCategory<Iterator<C>> >::value, 2>... >
std::size_t size_at_least( C&& c ) {
using std::begin; using std::end;
return end(c)-begin(c);
};
template<typename C, EnableFuncIf< !has_size_method<C>::value &&
!std::is_base_of< std::random_access_iterator_tag, IteratorCategory<Iterator<C>> >::value, 3>... >
std::size_t size_at_least( C&& c ) {
return 0;
};

template < typename It >
auto try_make_move_iterator(It i, std::true_type)
-> decltype(make_move_iterator(i))
{
return make_move_iterator(i);
}
template < typename It >
It try_make_move_iterator(It i, ...)
{
return i;
}

#include <iostream>
template<typename C1, typename C2>
C1&& append_containers( C1&& c1, C2&& c2 )
{
using std::begin; using std::end;
try_reserve( c1, size_at_least(c1) + size_at_least(c2) );

using is_rvref = std::is_rvalue_reference<C2&&>;
c1.insert( end(c1),
try_make_move_iterator(begin(c2), is_rvref{}),
try_make_move_iterator(end(c2), is_rvref{}) );

return std::forward<C1>(c1);
}

struct append_infix_op {} append;
template<typename LHS>
struct append_on_right_op {
LHS lhs;
template<typename RHS>
LHS&& operator=( RHS&& rhs ) {
return append_containers( std::forward<LHS>(lhs), std::forward<RHS>(rhs) );
}
};

template<typename LHS>
append_on_right_op<LHS> operator+( LHS&& lhs, append_infix_op ) {
return { std::forward<LHS>(lhs) };
}
template<typename LHS,typename RHS>
typename std::remove_reference<LHS>::type operator+( append_on_right_op<LHS>&& lhs, RHS&& rhs ) {
typename std::decay<LHS>::type retval = std::forward<LHS>(lhs.lhs);
return append_containers( std::move(retval), std::forward<RHS>(rhs) );
}

template<typename C>
void print_container( C&& c ) {
for( auto&& x:c )
std::cout << x <<",";
std::cout <<"
";
};

int main() {
std::vector<int> a = {0,1,2};
std::vector<int> b = {3,4,5};
print_container(a);
print_container(b);
a +append= b;
const int arr[] = {6,7,8};
a +append= arr;
print_container(a);
print_container(b);
std::vector<double> d = ( std::vector<double>{-3.14, -2, -1} +append= a );
print_container(d);
std::vector<double> c = std::move(d) +append+ a;
print_container(c);
print_container(d);
std::vector<double> e = c +append+ std::move(a);
print_container(e);
print_container(a);
}

呵呵。

现在，在@dyp的帮助下，使用从rhs移动数据、将数组附加到容器、将列表附加到容器、将容器从lhs移动。

请注意，由于EnableFunctionIf<>...技术的缘故，上面的代码不能进行clang编译。这套解决办法奏效了。

相关讨论

如果您想将向量添加到自身，两种流行的解决方案都将失败：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

std::vector<std::string> v, orig;

orig.push_back("first");
orig.push_back("second");

// BAD:
v = orig;
v.insert(v.end(), v.begin(), v.end());
// Now v contains: {"first","second","","" }

// BAD:
v = orig;
std::copy(v.begin(), v.end(), std::back_inserter(v));
// std::bad_alloc exception is generated

// GOOD, but I can't guarantee it will work with any STL:
v = orig;
v.reserve(v.size()*2);
v.insert(v.end(), v.begin(), v.end());
// Now v contains: {"first","second","first","second" }

// GOOD, but I can't guarantee it will work with any STL:
v = orig;
v.reserve(v.size()*2);
std::copy(v.begin(), v.end(), std::back_inserter(v));
// Now v contains: {"first","second","first","second" }

// GOOD (best):
v = orig;
v.insert(v.end(), orig.begin(), orig.end()); // note: we use different vectors here
// Now v contains: {"first","second","first","second" }

相关讨论