如何找到数组中的元素数量？

Question

我有一个int数组，我需要找到其中的元素数量。我知道它与sizeof有关，但我不确定如何使用它。

Answer 1

如果你的数组在范围内，你可以使用sizeof来确定它的大小（以字节为单位）并使用除法来计算元素的数量：

#define NUM_OF_ELEMS 10
int arr[NUM_OF_ELEMS];
size_t NumberOfElements = sizeof(arr)/sizeof(arr[0]);

如果您将数组作为函数参数接收或在堆中分配数组，则无法使用sizeof确定其大小。您必须以某种方式存储/传递大小信息才能使用它：

void DoSomethingWithArray(int* arr, int NumOfElems)
{
    for(int i = 0; i < NumOfElems; ++i) {
        arr[i] = /*...*/
    }
}

Answer 2

int a[20];
int length;
length = sizeof(a) / sizeof(int);

您可以使用其他方式将代码硬编码为int

假设你有一个数组array

你只需要：

int len = sizeof(array) / sizeof(array[0]);

Answer 3

我个人认为sizeof（a）/ sizeof（* a）看起来更干净。

我也更喜欢将其定义为宏：

#define NUM(a) (sizeof(a) / sizeof(*a))

然后你可以在for循环中使用它，因此：

for (i = 0; i < NUM(a); i++)

Answer 4

除非是字符数组，否则无法找到数组中的元素数。请考虑以下示例：

int main()
{
    int arr[100]={1,2,3,4,5};
    int size = sizeof(arr)/sizeof(arr[0]);
    printf("%d", &size);
    return 1;
}

即使元素数为5，上述值也会给出100。 如果它是一个字符数组，你可以线性搜索数组末尾的空字符串，并在你经过时增加计数器。

Answer 5

我使用上面建议的以下代码来评估我的二维数组中的元素数量：

#include <stdio.h>
#include <string.h>

void main(void)
{
    char strs[3][20] =
    {
        {"January"},
        {"February"},
        {""}
    };

    int arraysize = sizeof(strs)/sizeof(strs[0]);

    for (int i = 0; i < arraysize; i++)
    {
        printf("Month %d is: %s\n", i, strs[i]);
    }

}

很好用。据我所知，你不能在C数组中混合使用不同的数据类型，并且你应该拥有相同大小的所有数组元素（如果我是对的），因此你可以利用这个小技巧来利用它：

1. 使用sizeof（）函数计算整个2d数组的字节数（在本例中为3 * 20 = 60字节）
2. 使用sizeof（）函数计算第一个数组元素strs [0]的字节数（在本例中为20个字节）
3. 将整个大小除以一个元素的大小，这将为您提供元素数量

对于C中的2d数组，此剪切应该是可移植的，但是在其他编程语言中，它无法工作，因为您可以在不同大小的数组中使用不同的数据类型（如JAVA中）。

Answer 6

#include<stdio.h>
int main()
{
    int arr[]={10,20,30,40,50,60};
    int *p;
    int count=0;

    for(p=arr;p<&arr+1;p++)
        count++;

    printf("The no of elements in array=%d",count);

    return 0;
}

  

OUTPUT = 6

<强>说明

p是指向1-D数组的指针，并在循环for(p=arr,p<&arr+1;p++)中 我让p指向基地址。假设它的基地址是1000;如果我们增加p，那么它指向1002，依此类推。现在来看&arr的概念 - 它基本上代表整个数组，如果我们在整个数组中加1，即&arr+1，它给出地址1012，即下一个1-D数组的地址（在我们的例子中，int的大小是2），因此条件变为1000 <1012。

所以，基本上条件变为

for(p=1000;p<1012;p++)

现在让我们检查条件并计算值

• 第一次p=1000和p<1012条件为true：输入循环，将count的值增加为1.
• 第二次p=1002和p<1012条件为true：输入循环，将count的值增加为2.
• ...
• 第6次p=1010和p<1012条件为true：输入循环，将count的值增加到6。
• 上次p=1012和p<1012条件为false：在count=6语句中打印printf的值。

Answer 7

实际上，我们无法计算数组中存储了多少元素

但是您可以使用sizeof运算符找到数组的长度或大小。

但是为什么我们找不到我的数组中有多少个元素。

因为初始化数组编译器时，我们在程序上像a [10]（10个块的4个大小）那样给内存，如果我们在a [0] = 1，a [1] = 2，a [3] = 8;另一个块具有垃圾值，没人能分辨哪个值是垃圾，哪个值不是垃圾。这就是我们无法计算数组中有多少个元素的原因。我希望这可以帮助您理解。小概念

Answer 8

void numel(int array1[100][100])
{
    int count=0;
    for(int i=0;i<100;i++)
    {
        for(int j=0;j<100;j++)
        {
            if(array1[i][j]!='\0') 
            {
                count++;
                //printf("\n%d-%d",array1[i][j],count);
            }
            else 
                break;
        }
    }
    printf("Number of elements=%d",count);
}
int main()
{   
    int r,arr[100][100]={0},c;
    printf("Enter the no. of rows: ");
    scanf("%d",&r);
    printf("\nEnter the no. of columns: ");
    scanf("%d",&c);
    printf("\nEnter the elements: ");
    for(int i=0;i<r;i++)
    {
        for(int j=0;j<c;j++)
        {
            scanf("%d",&arr[i][j]);
        }
    }
    numel(arr);
}

这将显示矩阵中元素的确切数量，而与您在初始化时提到的数组大小无关（如果这就是您的意思）

Answer 9

如果我们不知道数组中的元素数以及用户在运行时给出的输入。然后我们可以将代码编写为

C代码：

while(scanf("%d",&array[count])==1) { 
  count++;
}

C ++代码：

while(cin>>a[count]) {
  count++;
}

现在，计数将包含输入的数组元素的数量。

Answer 10

问题很简单：给定一个C ++数组（例如x中的int x[10]），如何获取其中的元素数量？

一个明显的解决方案是以下宏（定义1）：

#define countof( array ) ( sizeof( array )/sizeof( array[0] ) )

我不能说这是不正确的，因为当给它一个数组时，它的确给出了正确的答案。但是，当您提供的不是数组时，相同的表达式会给您带来虚假的提示。例如，如果您有

int * p;

然后countof( p )总是在int指针和int大小相同的机器上（例如在Win32平台上）给您1。

此宏还错误地接受具有成员函数operator []的类的任何对象。例如，假设您写

class IntArray {
private:
    int * p;
    size_t size;
public:
    int & operator [] ( size_t i );
} x;

然后sizeof( x )将是x对象的大小，而不是x.p所指向的缓冲区的大小。因此，countof( x )不会为您提供正确的答案。

因此我们得出结论，定义1不好，因为编译器不会阻止您滥用它。它无法强制只能传递一个数组。

有什么更好的选择？

好吧，如果我们希望编译器确保countof的参数始终是数组，那么我们必须找到一个只允许数组的上下文。相同的上下文应拒绝任何非数组表达式。

某些初学者可以尝试使用此（定义2）：

template <typename T, size_t N>
size_t countof( T array[N] )
{
   return N;
}

他们认为，此模板函数将接受N个元素的数组并返回N。

不幸的是，由于C ++将数组参数与指针参数相同，因此无法编译，即上面的定义等同于：

template <typename T, size_t N>
size_t countof( T * array )
{
    return N;
}

现在很明显，函数体无法知道N是什么。

但是，如果函数需要一个数组引用，则编译器会确保实际参数的大小与声明匹配。这意味着我们可以对定义2进行小的修改（定义3）：

template <typename T, size_t N>
size_t countof( T (&array)[N] )
{
    return N;
}

此countof效果很好，您不能通过给它一个指针来愚弄它。但是，它是一个函数，而不是宏。这意味着您不能在期望编译时间常数的地方使用它。特别是，您不能编写如下内容：

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

我们能做些什么吗？

某人（我不知道它是谁，我只是在一个陌生作者的一段代码中看到它）提出了一个聪明的主意：将N从函数的主体移到返回类型（例如make函数返回一个由N个元素组成的数组），那么我们无需实际调用函数就可以获取N的值。

确切地说，我们必须使函数返回数组引用，因为C ++不允许您直接返回数组。

其实现是：

template <typename T, size_t N>
char ( &_ArraySizeHelper( T (&array)[N] ))[N];

#define countof( array ) (sizeof( _ArraySizeHelper( array ) ))

诚然，语法看起来很糟糕。确实，一些解释是必要的。

首先，顶级的东西

char ( &_ArraySizeHelper( ... ))[N];

说_ArraySizeHelper是一个函数，该函数返回对N个元素的char数组的引用（请注意＆）。

接下来，功能参数为

T (&array)[N]

是对N个元素的T数组的引用。

最后，countof被定义为函数_ArraySizeHelper的结果的大小。请注意，我们甚至不需要定义_ArraySizeHelper()，-声明就足够了。

有了这个新定义，

int x[10];

int y[ 2*countof(x) ]; // twice as big as x

成为我们所希望的有效。

我现在快乐吗？好吧，我认为这个定义绝对比我们访问过的其他定义更好，但是仍然不是我想要的。一方面，它不适用于在函数内部定义的类型。这是因为模板函数_ArraySizeHelper期望在全局范围内可以访问的类型。

我没有更好的解决方案。如果您知道一个，请告诉我。

Answer 11

超级容易。

只需使用sizeof()将分配的字节数除以数组数据类型的字节数即可。

例如给定一个名为myArray

的整数数组

int numArrElements = sizeof(myArray) / sizeof(int);

现在，如果数组的数据类型不是恒定的，并且可能会发生变化，请使等式中的除数使用第一个值的大小作为数据类型的大小

例如

int numArrElements = sizeof(myArray) / sizeof(myArray[0]);

Answer 12

sizeof返回其参数的大小（以字节为单位）。这不是您想要的，但可以提供帮助。

假设您有一个数组：

int array[4];

如果将sizeof应用于数组（sizeof(array)），它将以字节为单位返回其大小，在这种情况下为4 * int的大小，因此总计大约16个字节（取决于您的实现）。

如果将sizeof应用于数组的元素（sizeof(array[0])），它将返回其大小（以字节为单位），在这种情况下为int的大小，因此总共可能是4个字节（取决于您的实现）。

如果将第一个除以第二个，则将为：（4 * int的大小）/（int的大小）= 4;那正是您想要的。

所以这应该做：

sizeof(array) / sizeof(array[0])

现在，您可能想拥有一个宏来封装此逻辑，而不必再考虑应该如何做：

#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

您需要像在任何其他复杂宏中一样将所有宏括在圆括号中，并且也将每个变量都括在圆括号中，以避免与运算符优先级相关的意外错误。

现在您可以在像这样的任何数组上使用它：

int array[6];
ptrdiff_t nmemb;

nmemb = ARRAY_SIZE(array);
/* nmemb == 6 */

请记住，声明为数组的函数的参数并不是真正的数组，而是指向数组第一个元素的指针，因此这不适用于它们：

void foo(int false_array[6])
{
        ptrdiff_t nmemb;

        nmemb = ARRAY_SIZE(false_array);
        /* nmemb == sizeof(int *) / sizeof(int) */
        /* (maybe  ==2) */
}

但是如果您将指针传递给数组而不只是数组，则可以在函数中使用它：

void bar(int (*arrptr)[7])
{
        ptrdiff_t nmemb;

        nmemb = ARRAY_SIZE(*arrptr);
        /* nmemb == 7 */
}

Answer 13

假设您有一个元素为 1,3,4 的数组。 要知道它的长度，您需要使用 sizeof 函数，如下所示：

int myArray[] = {1,3,4};
int len = sizeof(myArray) / sizeof(myArray[0]);

您可以通过打印输出来检查元素的数量，如下所示：

cout<<"This array has " << len << " elements";
 

完整的程序如下：

#include <iostream>

using namespace std;

int main()
{
    
    
    int myArray[] = {1,3,4};
    int len = sizeof(myArray) / sizeof(myArray[0]);
 

    cout<<"The array has " << len << "elements";
    return 0;
}

Answer 14

只有当数组以这种格式声明时，我们才能找到数组中的元素数

int a[]={1,2,3,4,5,6};

数组元素个数为

 n=sizeof(a) / sizeof(a[0]);

如果像这样声明，我们应该无法计算数组大小int a[10]={1,2,3,4,5,6}

Answer 15

我主要找到一种简单的方法来执行循环内部的数组长度，就像那样

 int array[] = {10, 20, 30, 40};
 int i;
 for (i = 0; i < array[i]; i++) {
    printf("%d\n", array[i]);
 }

Answer 16

实际上，没有正确的方法来计算动态整数数组中的元素。但是，sizeof命令在Linux中正常工作，但在Windows中无法正常工作。从程序员的角度来看，不建议使用sizeof来获取动态数组中的元素数量。我们应该在制作数组时跟踪元素的数量。