当我向向量添加元素时，为什么向量的大小相同？ 我有这个C++结构： typedef unsigned long T; struct Node { T index; T length; Node(): index(0), length(0), next(0) {} Node(const T &ind, const T &len): index(ind), length(len), next(0) {} vector<Node*> next; };

我的问题：为什么一个空向量需要24个字节，而一个包含5个元素的向量仍然需要24个字节？这不是需要更多的记忆吗？比如*24+5*sizeof（Node*）*？

您想要

n.next.size（）

sizeof

完全是一个编译时操作，因为它只是查看类型来计算存储一个实例需要多少字节

sizeof（n.next）

告诉您需要多少字节才能保存

n.next

。因为它是一个

向量

，所以很可能使用3个指针（每个8字节）来实现——一个指针指向分配数组的开头，一个指针指向数据的结尾，一个指针指向分配数组的结尾

您需要

n.next.size（）

---

sizeof

完全是一个编译时操作，因为它只是查看类型来计算存储一个实例需要多少字节

sizeof（n.next）

告诉您需要多少字节才能保存

n.next

。因为它是一个

向量

，所以很可能使用3个指针（每个8字节）来实现——一个指针指向分配数组的开头，一个指针指向数据的结尾，一个指针指向分配数组的结尾

Vector是一种动态结构，具有固定的“足迹”，通常包含指向动态分配数据的指针

---

n.next.size（）

返回动态分配数据的大小

sizeof（n.next）

返回固定封装外形的大小。

Vector是一种动态结构，具有固定的“封装外形”，通常包含指向动态分配数据的指针

---

n.next.size（）

返回动态分配数据的大小

sizeof（n.next）

返回固定示意图的大小。

给定类型的所有对象的大小都相同，

sizeof（n.next）

相当于

sizeof（vector）

vector

实例不包含元素，它只指向元素，因此实例本身的大小始终相同

它的工作原理与此完全相同：

class A
{
public:
    A(int n) : p(new char[n]), s(n) {}
    int size() const { return s; }
private:
    char* p;
    int s;
};

int main()
{
    A a(1);
    A b(100);
    // These all print the same thing:
    std::cout << sizeof(a);
    std::cout << sizeof(b);
    std::cout << sizeof(A);
    // These are different:
    std::cout << a.size();  // Prints 1
    std::cout << b.size();  // Prints 100
}

A类
{
公众：
A（intn）：p（新字符[n]），s（n）{}
int size（）常量{return s；}
私人：
char*p；
int-s；
};
int main（）
{
A（1）；
A b（100）；
//这些都打印相同的内容：
std:：cout给定类型的所有对象的大小都相同，
sizeof（n.next）
相当于
sizeof（vector）

vector
实例不包含元素，它只指向元素，因此实例本身的大小始终相同

它的工作原理与此完全相同：

class A
{
public:
    A(int n) : p(new char[n]), s(n) {}
    int size() const { return s; }
private:
    char* p;
    int s;
};

int main()
{
    A a(1);
    A b(100);
    // These all print the same thing:
    std::cout << sizeof(a);
    std::cout << sizeof(b);
    std::cout << sizeof(A);
    // These are different:
    std::cout << a.size();  // Prints 1
    std::cout << b.size();  // Prints 100
}

A类
{
公众：
A（intn）：p（新字符[n]），s（n）{}
int size（）常量{return s；}
私人：
char*p；
int-s；
};
int main（）
{
A（1）；
A b（100）；
//这些都打印相同的内容：
std:：cout作为标准的向量实现通常会进行优化，以使其开始使用的空间超过所需的空间量。简单地说，该实现为向量（例如8个对象）规划空间，即使您要求的更少，并且只有在您超过此数字后才开始分配更多内存

如果您从不使用这些元素，这会浪费少量内存，但会消除为添加的每个元素重新分配内存的性能开销。确切数量取决于实现，有些可能不会这样做，但这是一种典型的优化

如果你想测量一个元素所占用的空间，你需要选择较大的数量；例如，放入100个对象并检查，然后放入200个对象并检查。对于较小的数量，你将看到一个恒定的大小，直到达到阈值。
作为标准的向量实现通常经过优化，以使用mor开始其生命简单地说，实现为向量规划空间，例如8个对象，即使你要求的更少，并且只有在你超过这个数字后才开始分配更多的内存

如果您从不使用这些元素，这会浪费少量内存，但会消除为添加的每个元素重新分配内存的性能开销。确切数量取决于实现，有些可能不会这样做，但这是一种典型的优化

如果你想测量一个元素所占用的空间，你需要测量更大的量；例如，放入100个对象并检查，然后放入200个对象并检查。对于较小的量，你会看到一个恒定的大小，直到你达到阈值。
int*x=new int[1]；int*y=new int[100]
。想想，为什么
sizeof（x）==sizeof（y）
，即使它们指向不同大小的数组？这两种情况下都是指针的大小？如果您至少需要知道向量使用了多少内存，请使用
sizeof（n.next）+n.next.capacity（）*sizeof（Node*）
如果您需要确切知道向量分配了多少内存，请为向量提供您自己的分配器。
int*x=new int[1]；int*y=new int[100]
。想想，为什么
sizeof（x）==sizeof（y）
，即使它们指向不同大小的数组？这两种情况下都是指针的大小？如果您至少需要知道向量使用了多少内存，请使用
sizeof（n.next）+n.next.capacity（）*sizeof（Node*）
如果您需要确切地知道该向量分配了多少内存，请为该向量提供您自己的分配器。不，我想知道下一个向量满时将占用多少字节，这意味着它有五个指向节点的指针。但我不知道如何计算它。@alekscooper如果您真的需要跟踪内存使用情况，请y、 你使用了错误的编程语言。如果你只是想知道发生了什么，请看“否”，我想知道我的
class A
{
public:
    A(int n) : p(new char[n]), s(n) {}
    int size() const { return s; }
private:
    char* p;
    int s;
};

int main()
{
    A a(1);
    A b(100);
    // These all print the same thing:
    std::cout << sizeof(a);
    std::cout << sizeof(b);
    std::cout << sizeof(A);
    // These are different:
    std::cout << a.size();  // Prints 1
    std::cout << b.size();  // Prints 100
}