Question

这个问题的灵感来自一个类似的问题：How does delete[] “know” the size of the operand array?

我的问题有点不同：有没有办法以编程方式确定C ++数组的大小？如果没有，为什么？我看到的每个接受数组的函数也需要一个整数参数来赋予它大小。但正如链接问题指出的那样，delete[]必须知道要释放的内存大小。

考虑这个C ++代码：

int* arr = new int[256];
printf("Size of arr: %d\n", sizeof(arr));

这会打印“Size of arr: 4”，这只是指针的大小。有一些打印256的函数会很好，但我不认为C ++中存在一个函数。（同样，问题的一部分是为什么它不存在。）

澄清：我知道如果我在堆栈而不是堆上声明数组（即“int arr[256];”），sizeof运算符将返回1024（数组） length * sizeof（int））。

Answer 1

delete []确实知道分配的大小。但是，该知识驻留在运行时或操作系统的内存管理器中，这意味着编译期间编译器无法使用它。并且sizeof()不是一个真正的函数，它实际上被编译器评估为常量，这是动态分配的数组无法做到的，它的大小在编译期间是未知的。

另外，请考虑以下示例：


int *arr = new int[256];
int *p = &arr[100];
printf("Size: %d\n", sizeof(p));

编译器如何知道p的大小是多少？问题的根源是C和C ++中的数组不是第一类对象。它们会衰减为指针，并且编译器或程序本身无法知道指针是指向由new分配的内存块的开头，还是指向单个对象或某个位置的内存。由new分配的一块内存中间。

这样做的一个原因是C和C ++将内存管理留给程序员和操作系统，这也是他们没有垃圾收集的原因。 new和delete的实现不是C ++标准的一部分，因为C ++旨在用于各种平台，这些平台可以以非常不同的方式管理它们的内存。如果您为最新的Intel CPU上运行的Windows框编写文字处理器，可以让C ++跟踪所有已分配的数组及其大小，但是当您编写运行的嵌入式系统时，这可能是完全不可行的。一个DSP。

Answer 2

不，在标准C ++中没有办法做到这一点。

没有什么理由不是我所知道的。可能，大小被认为是一个实现细节，最好不要暴露。请注意，当您说malloc（1000）时，无法保证返回的块是1000字节 - 只是它至少 1000字节。最有可能的是大约1020（1K减去4个字节的开销）。在这种情况下，“1020”大小是运行时库记住的重要大小。当然，这会在实现之间发生变化。

这就是为什么标准委员会添加了std：vector＆lt;＆gt;，它确实跟踪它的确切大小。

Answer 3

实际上有一种方法可以确定大小，但它不是“安全”，并且在编译器和编译器之间会有所不同...... 所以它根本不应该使用。< / p>

当你这样做时： int * arr = new int [256];

256是无关紧要的，你将得到256 * sizeof（int），假设这种情况为1024，这个值可能存储在（arr - 4）

所以给你一些“项目”

int * p_iToSize = arr - 4;

printf（“项目数量％d”，* p_iToSize / sizeof（int））;

对于每个malloc，new，无论你收到的continuos内存块之前是什么，都会分配一个空间，其中包含一些关于你所获得的内存块的信息。

Answer 4

处理此问题的常用方法是使用向量

int main()
{
   std::vector<int> v(256);
   printf("size of v is %i capacity is %i\n", sizeof(int) * v.size(), sizeof(int) * v.capacity());
}

或预定义大小

const int arrSize = 256;
int main()
{
    int array[arrSize];
    printf("Size of array is %i", sizeof(int) * arrSize);
}

Answer 5

一些魔法：

template <typename T, size_t S>
inline
size_t array_size(const T (&v)[S]) 
{ 
    return S; 
}

这就是我们在C ++ 11中的表现：

template<typename T, size_t S>
constexpr 
auto array_size(const T (&)[S]) -> size_t
{ 
    return S; 
}

Answer 6

根据您的应用程序，您可以在数组末尾创建“标记值”。

sentinel值必须具有一些独特的属性。

然后，您可以处理数组（或进行线性搜索）以获得sentinel值，并随时计算。一旦达到哨兵值，就可以计算阵数。

对于简单的C字符串，终止\ 0是Sentinel值的一个示例。

Answer 7

C ++决定添加new来做一个类型安全的malloc，而新的必须知道调用ctors的两个元素的大小和数量，所以删除调用dtors。在早期，您必须实际传递以删除传递给new的对象的数字。

string* p = new string[5];
delete[5] p;

然而，他们认为如果使用new＆lt; type＆gt; []，数字的开销很小。所以他们决定新[n]必须记住n并将其传递给删除。实现它有三种主要方式。

保留指向大小的指针哈希表
直接在矢量
做一些完全不同的事情

也许有可能获得这样的大小：

size_t* p = new size_t[10];
cout << p[-1] << endl;
// Or
cout << p[11] << endl;

或者他们都没有。

Answer 8

那是因为你的变量arr只是一个指针。它在内存中保存特定位置的地址，但不知道任何有关它的信息。您将其声明为int *，这为编译器提供了一些指示，指示在递增指针时要执行的操作。除此之外，您可能指向数组的开头或结尾，或指向堆栈或无效内存。但我同意你的意见，不能打电话给sizeof非常讨厌：）

QuantumPete

Answer 9

没有可移植的方法来确定C ++中动态分配的数组的大小，只给出它的指针。 C ++非常灵活，可以为用户提供动力。例如，该标准没有定义内存分配器必须如何工作，例如通过添加所需的大小标头。不需要标题可以提供更大的灵活性。

作为一个例子，考虑一个实现为char *数组的字符串。通常使用指针到数组的中间来挑选子串。例如，请参阅标准C库中的strtok函数。如果需要在每个数组之前嵌入某些标头，则需要在子字符串之前删除数组的部分内容。

处理标头的另一种方法是在一个内存块中放置数组头，并让它们指向其他地方的原始数组内存。在许多情况下，这将需要为每个引用进行两次指针查找，这将对性能产生很大的影响。有一些方法可以克服这些缺陷，但它们会增加复杂性并降低实施灵活性。

std :: vector模板是我最喜欢的保持数组大小绑定到数组本身的方法。

C是具有更好语法的可移植汇编语言。

Answer 10

一般来说，没有。 C和C ++中的数组只是内存块，没有附加簿记信息。如果不将数组的长度存储在内存中，并增加开销来实现这一点，那么在一般情况下是不可能的。

静态分配的数组有一个例外。例如，如果您声明：int a[50]，则sizeof(a)将起作用。这是可能的，因为[50]是数组的静态类型的一部分：它是编译器已知的。 sizeof在编译时解释。

但是，如果你创建一个指针：int *p = a，那么sizeof(p)将返回你提到的指针大小，而不是数组的大小，因为编译器不知道p点是什么至。

Answer 11

不幸的是，这是不可能的。在C和C ++中，程序员有责任记住数组的长度，因为数组长度不存储在任何地方。删除[]和free（）确实记住了已分配块的大小，但它们可能会分配比请求的内存更多的内存，因此它们的内部数据结构存储已分配内存块的大小可能无法为您提供阵列的确切大小。

请注意，C ++ STL向量（基本上是包含在具有一些辅助函数的类中的数组）会存储数组的长度，因此如果您确实需要此功能，则可以使用向量。

Answer 12

你不能，从根本上说：

void foo(int* arr);

int arr[100] = {0};

foo(arr+1); // Calls foo with a pointer to 100-1 elements.

C ++数组只不过是存储在连续内存区域中的对象集合。由于它们之间没有空洞（padding是在对象内部），你可以通过简单地对指针进行修改来找到数组的下一个元素。在CPU级别，这是一个简单的调整。 C ++只插入sizeof（元素）乘数。

请注意，实现可能会选择实现包含数组边界的“胖指针”。它们需要两倍大，因为你需要链接到某种“数组绑定描述符”。作为副作用，在这样的实现中，您可以调用delete [] (1+new int[5]);

Answer 13

不，没有办法做到这一点，你必须跟踪外部有多大。像std::vector这样的课程为您完成此任务。

Answer 14

现在有std::array，一个围绕常量数组的高效编译时包装器：

#include <array>

int main (int argc, char** argv)
{
    std::array<int, 256> arr;
    printf("Size of arr: %ld\n", arr.size());
}

参数为<type, #elements>。

您还可以获得其他一些细节，例如迭代器，空（）和max_size（）。

Answer 15

有没有办法以编程方式确定C ++数组的大小？如果没有，为什么？

不，除非你自己跟踪它。
因为如果编译器不必告诉除此之外的任何人关于该信息，它会减少编译器的约束。这是否可取是有争议的。

Answer 16

@Dima，

编译器如何知道p的大小是什么？

编译器必须知道p的大小;否则，它无法实现delete[]。编译器不需要告诉其他人如何解决这个问题。

有一种有趣的方法来验证这一点，将operator new[]返回的指针与new[]返回的指针进行比较。

Answer 17

编译器无法知道

char *ar = new char[100]

是一个包含100个字符的数组，因为它不会在内存中创建一个实际的数组，它只是在内存中创建一个指向100个未初始化字节的指针。

如果你想知道给定数组的大小，只需使用std :: vector。 std :: vector是一个更好的数组。

Answer 18

当您创建数组指针（使用模板创建包装器指针）时，您不能在创建对象数组时，您可以像这样获得数组的大小：

char* chars=new char[100];
printf("%d",*((int*)chars-1));

delete[]函数需要解构其中的所有对象。为此，new[]关键字将元素数量放在所有数组后面。

数组的主体是这样的：

int count;
ObjectType* data; //This value is returned when using new[]

Answer 19

我这样做的方法是将数组的大小除以第一个元素的大小

int intarray[100];
printf ("Size of the array %d\n", (sizeof(intarray) / sizeof(intarray[0]));

打印100

Answer 20

您可以创建一个额外的数组元素，然后应用将存储在数组中的最不可能的数字。然后，您可以通过传递该数字来确定通过某个函数的元素数量。

如果在创建时声明并初始化数组，则可以扫描它，然后生成与数组中任何元素都不匹配的数字。但是如果你然后修改其中一个元素，你将不知道该元素是否存储与最后一个元素相同的值，因此你必须生成一个新的数字存储在最后一个元素中。仔细研究所有这些，你也可以只在变量中存储创建时的元素总数。如果你只在一个函数中使用数组，那可能就是这种情况。

以编程方式确定C ++数组的大小？

20 个答案: