C++ 如何使用标准向量初始化自定义向量类型

我已经创建了一个样本容器，它内部存储在std:：vector中。我希望能够使用std:：vector初始化容器。所以我创建了一个构造函数，它接受std:：initializer_列表，还接受begin和end

但我似乎不能这样初始化：

const std::vector< uint8_t > vec1 { 1,2,3,4,5 };
UsingVectorExample ex{ vec1.begin(), vec1.end() };  // compilation errors on this line

const std:：vectorvec1{1,2,3,4,5}；
使用VectoreExample ex{vec1.begin（），vec1.end（）}；//此行上的编译错误

这里有什么问题？我该怎么修理

代码如下：

#include <vector>
#include <cstdint>

class UsingVectorExample
{
public:
    class iterator : public std::vector<uint8_t>::iterator
    {
    public:
        explicit iterator(typename std::vector<uint8_t>::iterator c)
            : std::vector<uint8_t>::iterator(c)
        {}
    };

    class const_iterator : public std::vector<uint8_t>::const_iterator
    {
    public:
        explicit const_iterator(typename std::vector<uint8_t>::const_iterator c)
            : std::vector<uint8_t>::const_iterator(c)
        {}
    };

    explicit UsingVectorExample(std::initializer_list<uint8_t> list)
        : m_vector(list.size())
    {
        m_vector.assign(list);
    }

    UsingVectorExample(iterator begin, iterator end)
        : m_vector(begin, end)
    {}

    UsingVectorExample(const_iterator begin, const_iterator end)
        : m_vector(begin, end)
    {}

    iterator begin()
    {
        return iterator(m_vector.begin());
    }

    iterator end()
    {
        return iterator(m_vector.end());
    }

    const_iterator begin() const
    {
        return const_iterator(m_vector.begin());
    }

    const_iterator end() const
    {
        return const_iterator(m_vector.end());
    }

    void push_back(const uint8_t& val)
    {
        m_vector.push_back(val);
    }

private:
    std::vector<uint8_t>  m_vector;
};


int main() {

    const std::vector< uint8_t > vec1 { 1,2,3,4,5 };
    UsingVectorExample ex{ vec1.begin(), vec1.end() };  // compilation errors on this line
}

#包括
#包括
使用VectorExample初始化
{
公众：
类迭代器：public std:：vector:：迭代器
{
公众：
显式迭代器（typename std:：vector:：迭代器c）
：std:：vector:：迭代器（c）
{}
};
类const_迭代器：public std:：vector:：const_迭代器
{
公众：
显式常量迭代器（typename std:：vector:：常量迭代器c）
：std:：vector:：const_迭代器（c）
{}
};
显式使用VectoreXample（std:：initializer\u列表）
：m_向量（list.size（））
{
m_向量赋值（列表）；
}
使用VectorExample（迭代器开始、迭代器结束）
：m_矢量（开始、结束）
{}
使用VectorExample（常量迭代器开始，常量迭代器结束）
：m_矢量（开始、结束）
{}
迭代器begin（）
{
返回迭代器（m_vector.begin（））；
}
迭代器结束（）
{
返回迭代器（m_vector.end（））；
}
常量迭代器begin（）常量
{
返回常量迭代器（m_vector.begin（））；
}
常量迭代器end（）常量
{
返回常量迭代器（m_vector.end（））；
}
无效推回（const uint8&val）
{
m_向量。推回（val）；
}
私人：
std：：向量m_向量；
};
int main（）{
const std：：vectorvec1{1,2,3,4,5}；
UsingVectoreExample ex{vec1.begin（），vec1.end（）}；//此行出现编译错误
}

这里的问题是迭代器构造函数是显式的。这意味着如果不使用VectoreExample:：const_迭代器，则无法将

vec1.begin（）

转换为

UsingVectorExample ex{ UsingVectorExample::const_iterator{vec1.begin()}, 
                       UsingVectorExample::const_iterator{vec1.end()} }; 
                       

要不必这样做，只需删除
显式
。您可以看到，在这种情况下工作
这里的问题是迭代器构造函数是显式的。这意味着如果不使用VectoreExample:：const_迭代器，则无法将
vec1.begin（）
转换为

UsingVectorExample ex{ UsingVectorExample::const_iterator{vec1.begin()}, 
                       UsingVectorExample::const_iterator{vec1.end()} }; 
                       

要不必这样做，只需删除
显式
。您可以看到，在此
中，您可以使用VectorExample（std:：vector:：iterator begin，std:：vector:：iterator end）
参数为
创建一个构造函数。如果查看例如，您将看到它自己的迭代器构造函数重载使用模板。这就是标准库中所有容器和函数处理迭代器的方式。您自己的迭代器不能从
std:：vector:：iterator
隐式构造。您可以使用VectoreExample（std:：vector:：iterator begin，std:：vector:：iterator end）为
创建一个构造函数
parameters。如果您查看例如，您将看到它自己的迭代器构造函数重载使用模板。这就是标准库中所有容器和函数处理迭代器的方式。不能从
std:：vector:：iterator
隐式构造自己的迭代器。