如何确定 C++ 中字符串数组的大小？

Question

我试图简单地打印出数组中包含的值。

我有一个名为“结果”的字符串数组。我不知道它到底有多大，因为它是自动生成的。

根据我所读到的内容，您可以通过执行以下操作来确定数组的大小：

sizeof(result)/sizeof(result[0])

这是正确的吗？因为对于我的程序， sizeof(result) = 16 和 sizeof(result[0]) = 16 这样代码会告诉我我的数组的大小为 1。

但是这看起来不正确，因为如果我手动打印出像这样的数组值：

std::cout << result[0] << "\n";
std::cout << result[1] << "\n";
std::cout << result[2] << "\n";
std::cout << result[3] << "\n";
etc...

...然后我看到我正在寻找的结果值。该数组的长度/大小超过 100 个值。

看起来确定数组的大小/长度应该非常简单......所以希望我在这里遗漏了一些东西。

我是一个 C++ 新手，所以任何帮助将不胜感激。

Answer 1

您无法在 C++ 中动态确定数组的大小。您必须将大小作为参数传递。

附带说明一下，使用标准库容器（例如矢量）可以缓解这种情况。

在您的 sizeof 示例中，sizeof(result) 正在询问指针的大小（可能是 std::string）。这是因为当传递给函数时，实际的数组类型会“衰减”为指向元素的指针类型（即使该函数被声明为采用数组类型）。 sizeof(result[0]) 返回数组中第一个元素的大小，巧合的是，它也是 16 个字节。在您的平台上，指针似乎是 16 字节（128 位）。

请记住，sizeof 在 C++ 中总是在编译时计算，而不是在运行时计算。

Answer 2

作为旁注，有更好的方法来检查类型安全的数组大小（对于数组在范围内并且尚未衰减为指针的情况）：

// simple: runtime result
template <typename T, std::size_t N>
inline std::size_t sizeof_array( T (&)[N] ) {
   return N;
}

// complex: compile time constant
template <typename T, std::size_t N>
char (&static_sizeof_array( T(&)[N] ))[N];   // declared, not defined
#defined SIZEOF_ARRAY( x ) sizeof(static_sizeof_array(x))

在这两种情况下，编译器都会检测到您是否尝试通过在指针（动态数组或衰减数组）中：

void f( int array[] ) { // really: void f( int *array )
{
//   sizeof_array(array);              // compile time error
//   int another[SIZEOF_ARRAY(array)]; // compile time error
}
int main() {
   int array[] = { 1, 2, 3 };
   std::cout << sizeof_array(array) << std::endl; // prints 3
   int another_array[ SIZEOF_ARRAY(array) ];
   std::cout << sizeof_array(another_array) << std::endl; // 3 again
}

Answer 3

如果你拥有的是一个“真实”数组，那么 sizeof(x)/sizeof(x[0]) 技巧就有效。然而，如果你拥有的确实是一个指针（例如从函数返回的东西），那么这个技巧就不起作用了——你最终会用指针的大小除以指针。它们是指向不同类型的指针，但在典型的系统上，所有指针的大小都相同，因此您将得到一个。即使指针大小不同，结果仍然与您拥有的字符串数量无关。

Answer 4

更好地使用 std::vector 而不是原始数组。然后您不必手动管理数组内存，您可以使用 size() 方法如果你想知道元素的数量。

如果您使用动态分配的原始数组，您需要自己跟踪其大小，则无法从数组中获取该大小。最好将其保存在额外的变量中。

Answer 5

sizeof(array)/sizeof(element) 适用于固定长度数组的固定长度数组（不是指针）。
作为字符串数组，我们最常使用指向各种（固定）长度字符串的指针的（固定长度）数组，因此这个技巧不起作用。
sizeof() 用于在编译时大小已知的对象。它不适用于动态分配的数据本身。

当对象包含指针（如字符串数组的情况）时，
sizeof() 返回最高级别（固定大小）结构的大小。通常它只是单个指针的大小。它不包括指针指向的已分配数据的大小。因为该数据实际上不是主对象的一部分，它确实是一个或多个单独的对象（我们在这里进行聚合而不是组合，请参阅 http://en.wikipedia.org/wiki/Object_composition）。

在 C++ 中，使用向量非常方便地满足您的需求。也可以使用其他合适的标准容器。
length() 和 size() 方法是同义词，请参阅 http://www.cplusplus。 com/reference/string/string/size/)

PS 请注意，对于 std::string s 对象 sizeof(s) 是一个常量，与 s.length() 返回的实际（变量）字符串长度无关。实际分配的内存大小由 s.capacity() 返回，并且可能大于 length()。

使用向量数组的示例：

#include <iostream>
#include <string>
#include <vector>

using namespace std;

int main()
{
    string s = "01234";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    s += "56789012345";
    cout << "s[" << s.length() << "]=\"" << s << "\"" << endl; 
    cout << "sizeof(s)=" << sizeof(s) << " (implementation dependent)" << endl;
    cout << endl;

    vector<string>vs={"12","23","345","456","567","67888","7899999999","8","9876543210"};

    cout << "vs[" << vs.size() << "]={";
    size_t sz=0;
    for (size_t index=0; index<vs.size(); index++)
    {
        sz+=vs[index].size();
        if (index>0)
            cout << ",";
        cout << "\"" << vs[index] << "\":" << vs[index].size();
    }
    cout << "}:" << sz << endl;
    cout << "sizeof(vs)=" << sizeof(vs) << " (implementation dependent)" << endl;

    return 0;
}

结果：

s[5]="01234"
sizeof(s)=8 (implementation dependent)

s[16]="0123456789012345"
sizeof(s)=8 (implementation dependent)

vs[9]={"12":2,"23":2,"345":3,"456":3,"567":3,"67888":5,"7899999999":10,"8":1,"9876543210":10}:39
sizeof(vs)=24 (implementation dependent)

Answer 6

template< class T, size_t N >
std::size_t Length(const T(&)[N])
{
    return N;
};

std::cout << Length(another_array) << std::endl;

Answer 7

在字符串向量中使用 size() 方法

Answer 8

需要注意的是：文本可以用不同的方法表示。文本数组也可以用不同的方法表示。

指向 C 风格字符串的指针数组

一种常见的方法是使用指向 char 的指针数组。问题是数组的大小并不代表所有文本的大小。此外，还必须建立数据或指针的所有权，因为可能必须删除文本（被调用者可以删除文本还是调用者可以删除文本吗？）。因为它是一个数组，所以数组的大小必须始终伴随着所有参数中的数组（除非数组始终是固定大小）。

char 数组 - 打包文本

另一种方法是传递 char 数组并使字符串在数组中连续。一个字符串跟在前一个字符串的终止字符之后。通过这个数组，可以表示所有字符串的总大小，没有浪费空间。同样，对于数组，数组的大小在传递时必须伴随数组。

std::string 数组

在 C++ 中，可以使用 std::string 表示文本。在本例中，数组表示字符串的数量（类似于上面的 C 字符串数组）。要获得所有字符串的总大小，必须将每个字符串的大小相加。由于这是一个数组，因此还必须传递数组的大小。

摘要

在运行时传递数组时，数组大小必须伴随数组。 sizeof 仅在编译时处理。一个更简单的结构是 std::vector ，它动态处理大小和内存分配。