C++ vector:：如何在C++；？

如果我有以下代码：

std::vector<char> myvector;
char myarr[10];
myvector.reserve(10);
myvector.assign(myarr, myarr + 3);

std:：vector myvector；
char-myarr[10]；
myvector.reserve（10）；
赋值（myarr，myarr+3）；

将最后一行（赋值）作为MycPy（和MyValue[0），MyARR，3），如果我不考虑更新成员变量或调整大小。 根据定义：

复制内存块从该位置复制num字节的值 直接指向源指向的内存块 目的地

源和源指向的对象的基础类型 目标指针与此函数无关；结果是一场灾难 数据的二进制副本

函数不检查中是否有任何终止的空字符 source-它总是精确复制num字节

为避免溢出，两个 目标和源参数应至少为num字节，并且 不应重叠（对于重叠的内存块，memmove更安全 方法）

现在是向量：

向量是表示数组的序列容器，数组可以在 尺寸

与阵列一样，向量使用连续的存储位置来存储它们的数据 元素，这意味着也可以使用 在指向其元素的常规指针上的偏移量，并且同样有效 就像在数组中一样。但与阵列不同，它们的大小可以动态变化， 其存储由容器自动处理

让我们深入了解一些实现，您将看到赋值是一切，但类似于MimcPy，即使您不考虑调整大小和成员变量更新……）

当然。。。与新要求的元素计数相比，它执行计数更大或更小的元素的复制，但执行内存重新分配、绑定和有效性检查等

Memcpy只是复制一个字节块，并且很高兴。矢量复制完整的元素

为了您的利益：

GCC接口

模板
无效的
赋值（\u inputierator\uuuuu first，\u inputierator\uuuu last）
{
__glibcxx\u检查\u有效\u范围（\u第一，最后）；
**_Base:：assign（_gnu_调试：：_Base（_first），
__gnu_调试：：__基本（_最后））**
此->\u M\u使所有无效（）；
_M_更新_保证的_容量（）；
}
无效的
分配（大小、类型、常数和）
{
_Base:：assign（_n，_）；
此->\u M\u使所有无效（）；
_M_更新_保证的_容量（）；
}
#ifdef\uuugxx\u实验性\uCXx0x__
无效的
分配（初始值设定项列表）
{
_Base:：assign（u_l）；
此->\u M\u使所有无效（）；
_M_更新_保证的_容量（）；
}
#恩迪夫

_基：：分配

void
分配（大小、类型、常量值、类型和值）
{M_fill_assign（{n，{u val）}
模板
无效的
赋值（\u inputierator\uuuuu first，\u inputierator\uuuu last）
{
//检查它是否为整数类型。如果是，则它不是迭代器。
typedef typename_是_整数：：_Integral_Integral；
_M_分配_分派（uu优先，_u最后，_积分（））；
}

M-实施（并非所有必需的实施）。。。

模板
无效的
矢量：：
_M_fill_assign（大小、常量值、类型和值）
{
如果（\u\n>容量（））
{
向量tmp（uu n，u val，_M_get_Tp_分配器（））；
__tmp.掉期（*本）；
}
否则，如果（\u\n>size（））
{
std:：fill（开始（），结束（），u_val）；
std:：uuu未初始化u填充u n_ua（此->u M_uimpl.u M_ufinish，
__n-大小（），
_M_get_Tp_分配器（））；
此->\u M_impl.\u M_finish+=\u n-size（）；
}
其他的
_M_erase_at_end（std:：fill_n（此->M_impl._M_start，__n，_val））；
}
}

---

而且越来越多的…

它应该更像

std:：copy

而不是

memcpy

<代码> MycPy太笨以至于不能处理很多代码<代码> vector <代码>必须处理.@ USER881301，STD：什么类型的东西：在字符的情况下复制考虑？（不考虑边界检查）？请阅读

vector:：assign

的文档，该文档会告诉您它会更改向量的大小

memcpy

不能这样做。它更像是

myvector.resize（3）后面的MimcPyType有点像“如果我不考虑3”，“3 + 4＝4”，谢谢你的反应清晰。
template<typename _InputIterator>
  void
    assign(_InputIterator __first, _InputIterator __last)
    {
        __glibcxx_check_valid_range(__first, __last);
        **_Base::assign(__gnu_debug::__base(__first),
                      __gnu_debug::__base(__last));**
         this->_M_invalidate_all();
         _M_update_guaranteed_capacity();
    }

  void
    assign(size_type __n, const _Tp& __u)
    {
        _Base::assign(__n, __u);
        this->_M_invalidate_all();
        _M_update_guaranteed_capacity();
    }

#ifdef __GXX_EXPERIMENTAL_CXX0X__
  void
    assign(initializer_list<value_type> __l)
    {
        _Base::assign(__l);
        this->_M_invalidate_all();
        _M_update_guaranteed_capacity();
    }
#endif

void
  assign(size_type __n, const value_type& __val)
  { _M_fill_assign(__n, __val); }


template<typename _InputIterator>
  void
    assign(_InputIterator __first, _InputIterator __last)
    {
        // Check whether it's an integral type.  If so, it's not an iterator.
        typedef typename _Is_integer<_InputIterator>::_Integral _Integral;
        _M_assign_dispatch(__first, __last, _Integral());
    }

template<typename _Tp, typename _Alloc>
  void
    vector<_Tp, _Alloc>::
       _M_fill_assign(size_t __n, const value_type& __val)
    {
        if (__n > capacity())
        {
            vector __tmp(__n, __val, _M_get_Tp_allocator());
            __tmp.swap(*this);
        }
        else if (__n > size())
        {
            std::fill(begin(), end(), __val);
            std::__uninitialized_fill_n_a(this->_M_impl._M_finish,
                                          __n - size(), __val,
                                          _M_get_Tp_allocator());
            this->_M_impl._M_finish += __n - size();
        }
        else
            _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val));
        }
    }