[英]Construction a vector from the concatenation of 2 vectors
有没有办法构造一个vector
作为2个vector
的串联(除了创建一个辅助函数?)
例如:
const vector<int> first = {13};
const vector<int> second = {42};
const vector<int> concatenation = first + second;
我知道vector
没有像string
那样的加法运算string
,但这就是我想要的行为。 这种concatenation
将包含:13和42。
我知道我可以像这样初始化concatenation
,但它阻止我进行concatenation
const
:
vector<int> concatenation = first;
first.insert(concatenation.end(), second.cbegin(), second.cend());
不,如果你需要的话,这是不可能的
const
。 我想你必须写一个帮助功能。 我把它写成:
std::vector<int> concatenate(const std::vector<int>& lhs, const std::vector<int>& rhs)
{
auto result = lhs;
std::copy( rhs.begin(), rhs.end(), std::back_inserter(result) );
return result;
}
称之为:
const auto concatenation = concatenate(first, second);
如果向量可能非常大(或包含复制成本昂贵的元素),那么您可能需要先reserve
以保存重新分配:
std::vector<int> concatenate(const std::vector<int>& lhs, const std::vector<int>& rhs)
{
std::vector<int> result;
result.reserve( lhs.size() + rhs.size() );
std::copy( lhs.begin(), lhs.end(), std::back_inserter(result) );
std::copy( rhs.begin(), rhs.end(), std::back_inserter(result) );
return result;
}
(就个人而言,如果有证据证明这是一个瓶颈,我只会烦恼)。
template<typename T>
std::vector<T> operator+(const std::vector<T>& v1, const std::vector<T>& v2){
std::vector<T> vr(std::begin(v1), std::end(v1));
vr.insert(std::end(vr), std::begin(v2), std::end(v2));
return vr;
}
这确实需要一个辅助“功能”,但至少它允许你使用它
const vector<int> concatenation = first + second;
class Vector : public vector<int>
{
public:
Vector operator+(const Vector& vec);
};
Vector Vector::operator+(const Vector& vec)
{
for (int i = 0; i < vec.size(); i++)
{
this->push_back(vec[i]);
}
return *this;
}
让我先说这是一个黑客,并且不会给出如何使用vector
来做到这一点的答案。 相反,我们将依赖sizeof(int) == sizeof(char32_t)
并使用u32string
来包含我们的数据。
这个答案非常清楚, 只有基元可以在basic_string
,并且任何大于32位的原语都需要编写自定义的char_traits
,但是对于int
我们只能使用u32string
。
可以通过以下方式验证此资格:
static_assert(sizeof(int) == sizeof(char32_t));
一旦尺寸平等已经建立,并与之类非知识const
data
,和emplace
或emplace_back
不能使用, u32string
可用于像一个vector<int>
,具有显着的夹杂物的加成opperator的:
const vector<int> first = {13};
const vector<int> second = {42};
const u32string concatenation = u32string(first.cbegin(), first.cend()) + u32string(second.cbegin(), second.cend());
[ 实例 ]
我遇到了同样的问题,并希望有一种比我提出的方式更容易的方式...似乎没有。
所以,如果你不介意帮助器模板类,一些迭代器技巧应该这样做:
#include <vector>
#include <iostream>
template<class T>
class concat
{
public:
using value_type = typename std::vector<T>::const_iterator::value_type;
using difference_type = typename std::vector<T>::const_iterator::difference_type;
using reference = typename std::vector<T>::const_iterator::reference;
using pointer = typename std::vector<T>::const_iterator::pointer;
using iterator_category = std::forward_iterator_tag;
concat(
const std::vector<T>& first,
const std::vector<T>& last,
const typename std::vector<T>::const_iterator& iterator) :
mFirst{first},
mLast{last},
mIterator{iterator}{}
bool operator!= ( const concat& i ) const
{
return mIterator != i.mIterator;
}
concat& operator++()
{
++mIterator;
if(mIterator==mFirst.end())
{
mIterator = mLast.begin();
}
return *this;
}
reference operator*() const
{
return *mIterator;
}
private:
const std::vector<T>& mFirst;
const std::vector<T>& mLast;
typename std::vector<T>::const_iterator mIterator;
};
int main()
{
const std::vector<int> first{0,1,2,3,4};
const std::vector<int> last{5,6,7,8,9};
const std::vector<int> concatenated(
concat<int>(first,last,first.begin()),
concat<int>(first,last,last.end()));
for(auto i: concatenated)
{
std::cout << i << std::endl;
}
return 0;
}
您可能必须实现operator ++(int)或operator ==,具体取决于您的STL如何实现InputIterator构造函数,这是我为MingW GCC提出的最小迭代器代码示例。
玩得开心! :)
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.