C++ 如何验证指向std向量内部数组的指针

我想写一个向量的内部数组。如果向量被初始化，我可以使用

data（）

来编写。
然而，如果向量是空的（但有足够的存储），我就无法直接写入向量的内部数组

#包括
#包括
使用名称空间std；
无效写入顺序（整数*v，大小长度）
{
对于（int i=0；i您是否希望使用
resize
，而不是
reserve
，以及
size
而不是
capacity
，
reserve
只为向量添加容量，而不实际增加大小。
resize
增加大小以匹配保留容量。
<不存在。分配内存不足，但当您调整向量大小（或使用足够的元素创建向量）时，您的代码可以正常工作：

int main（无效）
{
向量v（10）；//带10个元素的向量
write_seq（v.data（），v.size（））；//写入这10个元素
Couth
不必担心你需要预先存储多少内存。如果性能不是问题，你可以考虑使用自动可调整的插入插入迭代器来推推要推的步骤中的元素。
#include <vector>
#include <iostream>

template<typename Iterator>
void write_seq(Iterator v) {
    for (int i = 0; i < 10; i++) {
        *v = i;  // actually calls std::vector<>::push_back() internally
        v++;
    }
}

int main(void)
{
    std::vector<int> v;
    std::cout << "just write them data!\n";
    write_seq(std::back_inserter(v));
    std::cout << "seq length " << v.size() << "\n";
    return 0;
}

#包括
#包括
模板
无效写入顺序（迭代器v）{
对于（int i=0；i<10；i++）{
*v=i；//实际上在内部调用std:：vector:：push_back（）
v++；
}
}
内部主（空）
{
std：：向量v；
std:：cout您需要理解向量的
大小
和
容量
的概念。大小是指在分配内部空间时存储的元素数。容量始终大于或等于大小。如果您将元素插入向量并导致向量容量不足，它将自动增加通过分配两倍于当前容量的新空间来重新分配其容量，然后将现有元素复制到新空间中，然后删除旧空间

如果您计划在向量中插入大量元素，“自动增加容量”功能没有效率，因为它会不断分配新空间和复制元素。相反，您可以使用
reserve（）
预先分配足够的空间，从而避免继续分配新空间的过程

capacity（）：
返回容器当前已分配空间的元素数

reserve（）：
将向量的容量增加到给定大小或更大

size（）：
返回容器中的元素数

resize（）：
更改存储的元素数


回到您的问题，您只需将
保留
替换为
调整大小
：

int main(void)
{
    vector<int> v;
    cout << "reserve and write\n";
    v.resize(10);  // use resize() instead of reserve()
    write_seq(v.data(), v.size());
    cout << "seq length " << v.size() << "\n";
    return 0;
}


int main（无效）
{
向量v；
cout
reserve
不是
resize
如何避免这种情况
实际调整向量大小。@srabhishek函数不更改向量大小，因为它对向量一无所知。它处理原始内存。顺便说一句，我不认为“验证”是正确的词。您似乎期望写入
v[i]
会扩展向量的大小，但事实并非如此，就像给c数组中的越界索引赋值是未定义的一样behavior@idclev463035818是的，我认为写
v[I]
直接写入向量存储。确实如此。我的评论有点草率。这不是“像”使用c数组，而是使用c数组。您直接写入向量内部存储，即使它有容量，也使用了0个元素
显示向量的内部数组未填充。另外，我没有使用
resize（）
因为向量是空的。@srabhishek您似乎对
大小
和
容量
之间的区别有一个根本性的误解。
容量
是指数组分配了多少个元素。元素本身不能保证有效。
大小
是
容量
中有效元素的数量。您不能合法地为索引为
=size
的元素赋值，即使为它们分配了
容量
，因为它们尚未构造。对于POD类型，您可以不受此限制，但对于非POD类型，则不受此限制。分配两倍于当前容量is常见，但不能保证。任何因素都可以，只要它足以为
push\u back获得摊销的常量复杂性
int main(void)
{
    vector<int> v;
    cout << "reserve and write\n";
    v.resize(10);  // use resize() instead of reserve()
    write_seq(v.data(), v.size());
    cout << "seq length " << v.size() << "\n";
    return 0;
}


void write_seq(vector<int>& v, size_t len)
{
    for (int i = 0; i < len; i++)
        v.push_back(i);  // add an element to the vector, this changes the size
}

int main(void)
{
    vector<int> v;
    cout << "reserve and write\n";
    v.reserve(10);  // this does not change size, the vector is still empty
    write_seq(v, v.capacity());
    cout << "seq length " << v.size() << "\n";
    return 0;
}