C++ 允许动态分配的C对象数组

如果我有一个动态分配的类，比如

std:：vector

。使用该对象的元素创建数组有多大意义

我测试了以下内容：

std::vector<int> array[2];

array[0].push_back(10);
array[0].push_back(20);
array[0].push_back(30);


array[1].push_back(40);
array[1].push_back(50);
array[1].push_back(60);

for (auto x : array[0]) {
    std::cout << x << std::endl;
}

for (auto x : array[1]) {
    std::cout << x << std::endl;
}

std:：向量数组[2]；
数组[0]。推回（10）；
数组[0]。推回（20）；
数组[0]。推回（30）；
数组[1]。推回（40）；
数组[1]。推回（50）；
数组[1]。推回（60）；
用于（自动x:数组[0]）{
std：：cout这里没有未定义的行为

使用该对象的元素创建数组有多大意义

这完全取决于您和您的设计考虑。拥有一个向量数组是非常好的

那么，当我们创建一个包含两个元素的数组时，是否分配了内存

是，已分配阵列的内存

当我们向std:：vector添加新元素时，我们是否在数组边界之外写入

std:：vector
动态分配内存。默认构造的向量可能分配内存，也可能不分配内存。这取决于实现。在内部，该向量可能只是保存指针

一些实现可能比这更聪明，如果需求超过此限制，可以从没有动态分配的固定数量的元素切换到使用动态分配。
std:：string
实现通常通过重新调整内部指针存储的用途来保存字符串数据来实现这一点

请注意，如果要将一些元素推送到一个新的向量上，最好在该向量上调用
reserve
，以避免在它增长时不必要的重新分配。
这里没有未定义的行为

使用该对象的元素创建数组有多大意义

这完全取决于您和您的设计考虑。拥有一个向量数组是非常好的

那么，当我们创建一个包含两个元素的数组时，是否分配了内存

是，已分配阵列的内存

当我们向std:：vector添加新元素时，我们是否在数组边界之外写入

std:：vector
动态分配内存。默认构造的向量可能分配内存，也可能不分配内存。这取决于实现。在内部，该向量可能只是保存指针

一些实现可能比这更聪明，如果需求超过此限制，可以从没有动态分配的固定数量的元素切换到使用动态分配。
std:：string
实现通常通过重新调整内部指针存储的用途来保存字符串数据来实现这一点

请注意，如果要将一些元素推送到一个新向量上，最好在该向量上调用
reserve
，以避免在其增长时不必要的重新分配。
类型为
std:：vector
的对象具有固定大小，这取决于其实现

考虑以下演示程序

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> array[2];

    std::cout << "sizeof( std::vector<int> ) = " 
              << sizeof( std::vector<int> )
              << '\n';
                  
    std::cout << "sizeof( array = " 
              << sizeof( array )
              << '\n';
                      
    std::cout << '\n';
    
    array[0].push_back(10);
    array[0].push_back(20);
    array[0].push_back(30);


    array[1].push_back(40);
    array[1].push_back(50);
    array[1].push_back(60);
    
    std::cout << "sizeof( std::vector<int> ) = " 
              << sizeof( std::vector<int> )
              << '\n';
                  
    std::cout << "sizeof( array = " 
              << sizeof( array )
              << '\n';
                      
}   

#包括
#包括
int main（）
{
std:：向量数组[2]；
std:：cout类型为
std:：vector
的对象具有固定大小，这取决于其实现

考虑以下演示程序

#include <iostream>
#include <vector>

int main() 
{
    std::vector<int> array[2];

    std::cout << "sizeof( std::vector<int> ) = " 
              << sizeof( std::vector<int> )
              << '\n';
                  
    std::cout << "sizeof( array = " 
              << sizeof( array )
              << '\n';
                      
    std::cout << '\n';
    
    array[0].push_back(10);
    array[0].push_back(20);
    array[0].push_back(30);


    array[1].push_back(40);
    array[1].push_back(50);
    array[1].push_back(60);
    
    std::cout << "sizeof( std::vector<int> ) = " 
              << sizeof( std::vector<int> )
              << '\n';
                  
    std::cout << "sizeof( array = " 
              << sizeof( array )
              << '\n';
                      
}   

#包括
#包括
int main（）
{
std:：向量数组[2]；
std:：cout向量不将分配的内存存储在向量对象中。向量包含一个int表示大小，一个指向堆分配内存的指针，可能还有一些其他东西。因此向量数组很好，因为当向量增长时，正在重新分配的是堆内存，而这些内存都不在向量对象中ject（因此不在阵列内）@JerryJeremiah哦，是的，这实际上是有道理的。所以我们实际上是在创建一个指针数组。谢谢！向量不在向量对象中存储分配的内存。向量包含一个大小的int和一个指向某个堆分配内存的指针，可能还有一些其他东西。所以向量数组是好的，因为vector growth重新分配的是堆内存，所有内存都不在vector对象内（因此不在数组内）@JerryJeremiah哦，是的，这实际上是有道理的。所以我们实际上是在创建一个指针数组。谢谢！我想向量不太可能有类似于小字符串优化的功能，因为它只对，比如说，1 int或8
char
s有用。对于不一定不常见的字符串，但对于向量……我不明白为什么不能他的想法太疯狂了。想象一下，
std:：vector
。据我所知，标准并没有排除它。不，它当然不排除，但小字符串是常见的，而如果你有一个
std:：vector
，它可能是二进制数据的缓冲区，而对于任何其他的
值类型
，它可能是完全没有用。只是没有一个令人信服的理由来实现它（并承担在随之而来的存储机制之间切换的成本）。我想向量不太可能有小字符串优化的等价物，因为它只对1 int或8
char
s有用。对于不一定不常见的字符串，但对于向量…我不明白为什么这是一个疯狂的概念。想象一下
std:：vector
。据我所知，标准并没有排除它知道。不，这当然不排除，但小字符串很常见，而如果你有一个
std:：vector
，它可能是一个二进制数据的缓冲区，而对于任何其他
value\u类型
，它可能是完全无用的。只是没有一个令人信服的理由去实现它（并承担在随之而来的存储机制之间切换的成本）。