这个问题已经在这里有一个答案：
- 尼斯办法向量追加到自己 4个回答
比方说，我有一个vector<string>包含“A”和“B”，我想自我复制的2倍，使载体现在包含“A”，“B”，“A”，“B”，“A”， “b”
有什么比用更好的方法for和push_back ？
Answer 1:
我最初的想法：
myvec.reserve(myvec.size()*3); //reserve not only speeds things upt it also protects us ftom iterator invalidation
vector<string>::iterator it = myvec.end(); //we ant to add two times the origional onto the end so we save the end of the origional end
myvec.insert(myvec.end(), myvec.begin(), it);
myvec.insert(myvec.end(), myvec.begin(), it);
由于埃米利奥加拉瓦利亚为第一指出这个问题，在这里看到很多原因，这有问题： 有没有性病::矢量::插入（）如果向量有足够的空间（通过储备创造）迭代器失效？
第二次尝试：
std::size_t size = myvec.size();
myvec.resize(size*3); //resize must protects us from iterator invalidation
vector<string>::iterator it = myvec.begin()+size;
std::copy(myvec.begin(),it,it);
std::copy(myvec.begin(),it,it+size);
因为没有实现将会卫生组织的默认构造函数在堆上分配的东西来实现的std :: string这一点应引起减少堆的访问，因此会比其他人更快的例子。
另一个堆存取的最小化是将载体复制到另一个刀片，然后在原件移动，我偷埃米利奥加拉瓦利亚代码和拉皮条它：
{
vector<string> m = { "a", "b" };
auto n = m; // keep initial value safe
m.reserve(3 * m.size()); // preallocate, to avoid consecutive allocations
m.insert(m.end, n.begin(), n.end());
std::for_each(n.begin(),n.end(),[&n](std::string &in){n.emplace_back(std::move(in));});
}
Answer 2:
vector<string> m = { "a", "b" };
auto n = m; // keep initial value safe
m.reserve(3 * m.size()); // preallocate, to avoid consecutive allocations
m.insert(m.end, n.begin(), n.end());
m.insert(m.end, n.begin(), n.end());
Answer 3:
我首先想到的是要避免无效迭代器的问题如下。
{ // note: nested scope
vector<string> temp(vec); // 1st copy
temp.insert(temp.end(), vec.begin(), vec.end()); // 2nd copy
temp.insert(temp.end(), vec.begin(), vec.end()); // 3rd copy
temp.swap(vec); // swap contents before temp is destroyed
}
经过审查，我认为PorkyBrain和埃米利奥加拉瓦利亚的回答可能更有意义。
Answer 4:
这里有一个简单的方法：
template<typename T, typename A1, typename A2>
std::vector<T, A1> operator+( std::vector<T, A1> left, std::vector<T, A2> const& right ) {
left.insert( left.end(), right.begin(), right.end() );
return left;
}
int main() {
std::vector<string> m = { "a", "b" );
m = m + m + m;
}
但正如指出的@ChristianAmmer，压倒一切的operator+上std::vector是不明确的。 这将是错误的。
所以，你可以去写一个完整的缀名为operator语法，并使用C ++的魔法将其嵌入在C ++语言，以摆脱这种模糊的。 排序是这样的：
#include <utility>
template<typename Operation, short op>
struct InfixOp {
Operation* self() { return static_cast<Operation*>(this); }
Operation const* self() const { return static_cast<Operation const*>(this); }
};
template<typename first_type, typename Infix, short op>
struct PartialForm {
Infix const* infix;
first_type a;
template<typename T>
PartialForm(T&& first, Infix const* i):infix(i), a(std::forward<T>(first)) {}
};
#define OVERRIDE_OPERATORS(OP, CODE) \
template<\
typename Left,\
typename Operation\
>\
PartialForm<typename std::remove_reference<Left>::type, Operation, CODE> operator OP( Left&& left, InfixOp<Operation, CODE> const& op ) {\
return PartialForm<typename std::remove_reference<Left>::type, Operation, CODE>( std::forward<Left>(left), op.self() );\
}\
\
template<\
typename Right,\
typename First,\
typename Operation\
>\
auto operator OP( PartialForm<First, Operation, CODE>&& left, Right&& right )\
->decltype( (*left.infix)( std::move( left.a ), std::forward<Right>(right)) )\
{\
return (*left.infix)( std::move( left.a ), std::forward<Right>(right) );\
}
OVERRIDE_OPERATORS(+, '+')
OVERRIDE_OPERATORS(*, '*')
OVERRIDE_OPERATORS(%, '%')
OVERRIDE_OPERATORS(^, '^')
OVERRIDE_OPERATORS(/, '/')
OVERRIDE_OPERATORS(==, '=')
OVERRIDE_OPERATORS(<, '<')
OVERRIDE_OPERATORS(>, '>')
OVERRIDE_OPERATORS(&, '&')
OVERRIDE_OPERATORS(|, '|')
//OVERRIDE_OPERATORS(!=, '!=')
//OVERRIDE_OPERATORS(<=, '<=')
//OVERRIDE_OPERATORS(>=, '>=')
template<typename Functor, char... ops>
struct Infix:InfixOp<Infix<Functor, ops...>, ops>...
{
Functor f;
template<typename F>
explicit Infix(F&& f_in):f(std::forward<F>(f_in)) {}
Infix(Infix<Functor, ops...> const& o):f(o.f) {}
Infix(Infix<Functor, ops...>&& o):f(std::move(o.f)) {}
Infix(Infix<Functor, ops...>& o):f(o.f) {}
template<typename L, typename R>
auto operator()( L&& left, R&& right ) const
-> decltype( f(std::forward<L>(left), std::forward<R>(right)))
{
return f(std::forward<L>(left), std::forward<R>(right));
}
};
template<char... ops, typename Functor>
Infix<Functor, ops...> make_infix( Functor&& f )
{
return Infix<Functor, ops...>(std::forward<Functor>(f));
}
#include <vector>
struct append_vectors {
template<typename T>
std::vector<T> operator()(std::vector<T> left, std::vector<T>const& right) const {
left.insert(left.end(), right.begin(), right.end());
return std::move(left);
}
};
struct sum_elements {
template<typename T>
std::vector<T> operator()(std::vector<T> left, std::vector<T>const& right) const {
for(auto it = left.begin(), it2 = right.begin(); it != left.end() && it2 != right.end(); ++it, ++it2) {
*it = *it + *it2;
}
return left;
}
};
struct prod_elements {
template<typename T>
std::vector<T> operator()(std::vector<T> left, std::vector<T>const& right) const {
for(auto it = left.begin(), it2 = right.begin(); it != left.end() && it2 != right.end(); ++it, ++it2) {
*it = *it * *it2;
}
return left;
}
};
#include <iostream>
int main() {
auto append = make_infix<'+'>(append_vectors());
auto sum = make_infix<'+'>(sum_elements());
auto prod = make_infix<'*'>(prod_elements());
std::vector<int> a = {1,2,3};
a = a +append+ a +append+ a;
a = a +sum+ a;
a = a *prod* a;
std::cout << a.size() << "\n";
for (auto&& x:a) {
std::cout << x << ",";
}
std::cout << "\n";
}
它具有清晰的优势，在您使用的地步（我的意思是， a = a +append+ a非常清楚什么打算做），以作为一个有点棘手的成本，了解它是如何工作的，有点冗长对于这样一个简单的问题。
但至少不确定性消失了，这是一件好事，对吧？
文章来源: How to self-copy a vector? [duplicate]
