从 2 个向量的串联构造一个向量

Question

有没有办法将 vector 构造为 2 vector 的串联（除了创建辅助函数？）

例如：

const vector<int> first = {13};
const vector<int> second = {42};
const vector<int> concatenation = first + second;

我知道 vector 没有像 string 这样的加法运算符，但这就是我想要的行为。这样 concatenation 将包含：13 和 42。

我知道我可以像这样初始化concatenation，但是它阻止我进行 concatenation const:

vector<int> concatenation = first;
first.insert(concatenation.end(), second.cbegin(), second.cend());

Answer 1

我觉得你得写一个帮助函数。我会写成：

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;
}

（就个人而言，只有在有证据表明这是一个瓶颈时，我才会打扰）。

Answer 2

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;
}

这确实需要一个助手 "function"，但至少它允许您将其用作

const vector<int> concatenation = first + second;

Answer 3

不，如果你需要那是不可能的

没有定义辅助函数，并且
可以声明生成的向量 const。

Answer 4

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;
}

Answer 5

首先让我说这是一个 hack，不会给出如何使用 vector 做到这一点的答案。相反，我们将依赖 sizeof(int) == sizeof(char32_t) 并使用 u32string 来包含我们的数据。

This answer 非常清楚只有基元可以在 basic_string 中使用，并且任何大于 32 位的基元都需要写入自定义 char_traits，但对于 int 我们可以只使用 u32string.

可以通过以下方式验证此资格：

static_assert(sizeof(int) == sizeof(char32_t));

一旦建立大小相等，并且知道不能使用诸如非const data 和 emplace 或 emplace_back 之类的东西，u32string 可以像 vector<int> 一样使用，值得注意的是包含一个加法运算符：

const vector<int> first = {13};
const vector<int> second = {42};
const u32string concatenation = u32string(first.cbegin(), first.cend()) + u32string(second.cbegin(), second.cend());

[Live Example]

Answer 6

我在寻找同样的东西时遇到了这个问题，希望有比我想出的方法更简单的方法......似乎没有。

因此，如果您不介意辅助模板，一些迭代器技巧应该可以做到这一点 class:

#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 提出的最小迭代器代码示例。

玩得开心！ :)

从 2 个向量的串联构造一个向量

Construction a vector from the concatenation of 2 vectors

c++

constructor

initialization

vector

addition