如何在C中确定数组的大小？

How do I determine the size of my array in C?

如何确定C中数组的大小？

也就是说，数组可以容纳的元素数？

执行概要： P / < >

1 2	int a[17]; size_t n = sizeof(a)/sizeof(a[0]);

完整的回答： P / < >

尺寸来确定你的阵列中的字节，你可以使用"sizeof 摄影师： P / < >

1 2	int a[17]; size_t n = sizeof(a);

在我的电脑，波是4字节长，所以N 68。 P / < >

来确定的一些元素的阵列中，我们可以divide 的总尺寸的尺寸由阵列的阵列元。你可以这样做与类型，像这样： P / < >

1 2	int a[17]; size_t n = sizeof(a) / sizeof(int);

得到适当的答案(68 / 4 = 17)，但如果类型 a改变了，你将拥有的讨厌的错误，如果你忘了改变 "sizeof(int)为好。 P / < >

这样的优先股，divisor也sizeof(a[0])，尺寸的 zeroeth元的阵列。 P / < >

1 2	int a[17]; size_t n = sizeof(a) / sizeof(a[0]);

另一个优势是，你可以现在容易parameterize 阵列的名称在宏得到： P / < >

1
2
3
4

#define NELEMS(x) (sizeof(x) / sizeof((x)[0]))

int a[17];
size_t n = NELEMS(a);

sizeof方法是正确的方法，如果您处理的数组不是作为参数接收的。作为参数发送到函数的数组被视为指针，因此sizeof将返回指针的大小，而不是数组的大小。

因此，在函数内部，此方法不起作用。相反，总是传递一个额外的参数size_t size，指示数组中元素的数量。

测试：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <stdio.h>
#include <stdlib.h>

void printSizeOf(int intArray[]);
void printLength(int intArray[]);

int main(int argc, char* argv[])
{
int array[] = { 0, 1, 2, 3, 4, 5, 6 };

printf("sizeof of array: %d
", (int) sizeof(array));
printSizeOf(array);

printf("Length of array: %d
", (int)( sizeof(array) / sizeof(array[0]) ));
printLength(array);
}

void printSizeOf(int intArray[])
{
printf("sizeof of parameter: %d
", (int) sizeof(intArray));
}

void printLength(int intArray[])
{
printf("Length of parameter: %d
", (int)( sizeof(intArray) / sizeof(intArray[0]) ));
}

输出(在64位Linux操作系统中)：

1
2
3
4

sizeof of array: 28
sizeof of parameter: 8
Length of array: 7
Length of parameter: 2

输出(在32位Windows操作系统中)：

1
2
3
4

sizeof of array: 28
sizeof of parameter: 4
Length of array: 7
Length of parameter: 1

它也值得noting，sizeof没有帮助的时候，dealing与一个阵列value，腹部decayed到指针：即使，虽然这是一个阵列发射点， compiler它也同样年代的指针到一个单一的去你的阵列。指针并不是"记住"其他的什么样的阵列，是用来initialize它。 P / < >

1
2
3
4
5
6

int a[10];
int* p = a;

assert(sizeof(a) / sizeof(a[0]) == 10);
assert(sizeof(p) == sizeof(int*));
assert(sizeof(*p) == sizeof(int));

"sizeof"诡计"是最好的方式，我知道，有一个小但(给我，这可主要的PET peeve)是重要的变化在使用parenthesis。 P / < >

20世纪的维基百科的进入使清，C的sizeof也没有的功能；它的一个摄影师。因此，它并不是require parenthesis在ITS argument，除非"argument的类型的名称。这是很容易去记住，因为它使"argument看起来像铸造expression，这也parenthesis用途。 P / < >

所以，如果你有以下： P / < >

1	int myArray[10];

你可以找到一些元素的吸附与代码，像这样： P / < >

1	size_t n = sizeof myArray / sizeof *myArray;

是的，对我的发展，很多easier比的替代与parenthesis。我也喜欢用英语asterisk在正确的手部部分，由于它的更多的concise比indexing。 P / < >

当然，这是compile时间太，所以没有需要担心的分裂的影响性能的计划。所以无论你可以使用这种格式。 P / < >

它总是最好的使用到sizeof在人的实际对象，当你有一个，而不是C型，因为然后你不需要去担心一个制作误差和stating同步错误的类型。 P / < >

为审，说你有一个功能，outputs一些数据作为流的字节，为审在的网络。让我们知道send()功能，和让它把20世纪arguments指针对象送，和在对象的字节数。所以，prototype变成： P / < >

1	void send(const void *object, size_t size);

然后你需要发送一个integer，所以你的代码它起来，像这样： P / < >

1 2	int foo = 4711; send(&foo, sizeof (int));

现在，你已经introduced的subtle方式吸附在枪杀自己的脚，由specifying类型的foo在两个地方。如果一个变化，但是其他的没有，断裂的代码。因此，总是这样做： P / < >

1	send(&foo, sizeof foo);

现在你在protected。当然，你复制的名称为"可变的，但是，腹部的高概率的突破的方式在一个同步的compiler可以detect，如果你改变它。 P / < >

1	int size = (&arr)[1] - arr;

查看此链接以获取解释

可以使用sizeof运算符，但它不适用于函数，因为它将引用指针可以执行以下操作来查找数组的长度：

1	len = sizeof(arr)/sizeof(arr[0])

最初在此处找到的代码：C程序查找数组中的元素数

如果知道数组的数据类型，则可以使用如下内容：

1
2
3

int arr[] = {23, 12, 423, 43, 21, 43, 65, 76, 22};

int noofele = sizeof(arr)/sizeof(int);

或者，如果您不知道数组的数据类型，您可以使用如下内容：

1	noofele = sizeof(arr)/sizeof(arr[0]);

注意：只有在运行时没有定义数组(如malloc)，并且没有在函数中传递数组时，此操作才有效。在这两种情况下，EDOCX1(数组名)都是指针。

每个人都在错误地使用评估结果的宏ARRAYELEMENTCOUNT(x)。实际上，这只是一个敏感问题，因为您不能有导致"array"类型的表达式。

1
2
3
4

/* Compile as: CL /P"macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x[0]))

ARRAYELEMENTCOUNT(p + 1);

实际计算为：

1	(sizeof (p + 1) / sizeof (p + 1[0]));

反之

1
2
3
4

/* Compile as: CL /P"macro.c" */
# define ARRAYELEMENTCOUNT(x) (sizeof (x) / sizeof (x)[0])

ARRAYELEMENTCOUNT(p + 1);

正确评估为：

1	(sizeof (p + 1) / sizeof (p + 1)[0]);

这实际上与数组的大小没有太大的关系。我刚注意到，没有真正观察到C预处理器是如何工作的，会有很多错误。您总是包装宏参数，而不是可能涉及的表达式。

这是正确的，我的例子不好。但这正是应该发生的。正如我前面提到的，p + 1将以指针类型结束，并使整个宏失效(就像您试图在带有指针参数的函数中使用宏一样)。

在一天结束的时候，在这种特殊的情况下，错误并不重要(所以我只是在浪费每个人的时间；huzzah！)，因为没有"array"类型的表达式。但实际上，我认为关于预处理器评估子表的要点很重要。

为multidimensional arrays它更多的一个复杂的点。oftenly人物的显式定义的宏constants，公元前 P / < >

1
2
3
4
5
6
7
8

#define g_rgDialogRows 2
#define g_rgDialogCols 7

static char const* g_rgDialog[g_rgDialogRows][g_rgDialogCols] =
{
{"", "", "", " 494"," 210"," Generic Sample Dialog","" },
{" 1"," 330"," 174"," 88", "", " OK", "" },
};

但这些constants可以evaluated美元compile时间也与sizeof： P / < >

1
2
3
4
5
6
7
8
9

#define rows_of_array(name) \
(sizeof(name ) / sizeof(name[0][0]) / columns_of_array(name))
#define columns_of_array(name) \
(sizeof(name[0]) / sizeof(name[0][0]))

static char* g_rgDialog[][7] = { /* ... */ };

assert( rows_of_array(g_rgDialog) == 2);
assert(columns_of_array(g_rgDialog) == 7);

注意，这种工作的代码在C和C + +。为arrays与比使用两个尺寸 P / < >

1 2	sizeof(name[0][0][0]) sizeof(name[0][0][0][0])

等，循环往复。 P / < >

以C为单位的数组大小：

1
2
3
4
5

int a[10];
size_t size_of_array = sizeof(a); // Size of array a
int n = sizeof (a) / sizeof (a[0]); // Number of elements in array a
size_t size_of_element = sizeof(a[0]); // Size of each element in array a
// Size of each element = size of type

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

1	#define SIZE_OF_ARRAY(_array) (sizeof(_array) / sizeof(_array[0]))

"你引入了一种巧妙的方式来射中自己的脚"

C"本机"数组不存储其大小。因此，建议将数组的长度保存在单独的变量/const中，并在传递数组时传递它，即：

1 2	#define MY_ARRAY_LENGTH 15 int myArray[MY_ARRAY_LENGTH];

您应该始终避免使用本机数组(除非您不能这样做，否则请注意您的脚)。如果您正在编写C++，请使用STL的"vector"容器。与数组相比，它们提供了几乎相同的性能"，而且它们更有用！

1
2
3
4
5
6
7
8
9

// vector is a template, the <int> means it is a vector of ints
vector<int> numbers;

// push_back() puts a new value at the end (or back) of the vector
for (int i = 0; i < 10; i++)
numbers.push_back(i);

// Determine the size of the array
cout << numbers.size();

见：http://www.cplusplus.com/reference/stl/vector/

马格纳斯：@标准defines sizeof年代yielding一些的字节在sizeof(char)和对象，也总是一个。一些部位的字节可以在具体实施。 P / < >

编辑：ANSI C + +标准的部分条款sizeof： P / < >

The sizeof operator yields the number of bytes in the object representation of its operand. [...] sizeof (char), sizeof (signed char) and sizeof (unsigned char) are 1; the result of sizeof applied to any other fundamental type is implementation-defined.

1.6节的C + +记忆模型： P / < >

The fundamental storage unit in the C++ memory model is the byte. A byte is at least large enough to contain any member of the basic execution character set and is composed of a contiguous sequence of bits, the number of which is implementation-defined.

@Skizz: I am pretty sure I am right, although the best"source" I can give you at the moment is Wikipedia, from the article on sizeof:

维基百科是错误的，skizz是正确的。sizeof(char)1，通过定义。 P / < >

我的意思是，只要读一读《维基百科的录入到closely真的看到，它是错误的。"multiples of字符"。sizeof(char)不能完成任何事超过"1"。如果是的话，说，2，它会意味着，sizeof(char)是两次尺寸的字符。 P / < >

如果您真的想这样做来传递数组，我建议实现一个结构来存储指向您想要的类型的指针，一个数组和一个表示数组大小的整数。然后你可以把它传递给你的函数。只需将数组变量值(指向第一个元素的指针)分配给该指针即可。然后，您可以使用Array.arr[i]获取第i个元素，并使用Array.size获取数组中的元素数。

我给你写了一些代码。它不是很有用，但是您可以用更多的特性来扩展它。不过，老实说，如果这些是您想要的东西，您应该停止使用C，并使用具有这些内置功能的其他语言。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

/* Absolutely no one should use this...
By the time you're done implementing it you'll wish you just passed around
an array and size to your functions */
/* This is a static implementation. You can get a dynamic implementation and
cut out the array in main by using the stdlib memory allocation methods,
but it will work much slower since it will store your array on the heap */

#include <stdio.h>
#include <string.h>
/*
#include"MyTypeArray.h"
*/
/* MyTypeArray.h
#ifndef MYTYPE_ARRAY
#define MYTYPE_ARRAY
*/
typedef struct MyType
{
int age;
char name[20];
} MyType;
typedef struct MyTypeArray
{
int size;
MyType *arr;
} MyTypeArray;

MyType new_MyType(int age, char *name);
MyTypeArray newMyTypeArray(int size, MyType *first);
/*
#endif
End MyTypeArray.h */

/* MyTypeArray.c */
MyType new_MyType(int age, char *name)
{
MyType d;
d.age = age;
strcpy(d.name, name);
return d;
}

MyTypeArray new_MyTypeArray(int size, MyType *first)
{
MyTypeArray d;
d.size = size;
d.arr = first;
return d;
}
/* End MyTypeArray.c */

void print_MyType_names(MyTypeArray d)
{
int i;
for (i = 0; i < d.size; i++)
{
printf("Name: %s, Age: %d
", d.arr[i].name, d.arr[i].age);
}
}

int main()
{
/* First create an array on the stack to store our elements in.
Note we could create an empty array with a size instead and
set the elements later. */
MyType arr[] = {new_MyType(10,"Sam"), new_MyType(3,"Baxter")};
/* Now create a"MyTypeArray" which will use the array we just
created internally. Really it will just store the value of the pointer
"arr". Here we are manually setting the size. You can use the sizeof
trick here instead if you're sure it will work with your compiler. */
MyTypeArray array = new_MyTypeArray(2, arr);
/* MyTypeArray array = new_MyTypeArray(sizeof(arr)/sizeof(arr[0]), arr); */
print_MyType_names(array);
return 0;
}

最好的方法是将这些信息保存在一个结构中，例如：

1
2
3
4

typedef struct {
int *array;
int elements;
} list_s;

实现所有必要的功能，如创建、销毁、检查相等性以及您需要的所有其他功能。作为参数传递更容易。

函数sizeof返回数组在内存中使用的字节数。如果要计算数组中的元素数，应将该数除以数组的sizeof变量类型。比如说int array[10];，如果您的计算机中的变量类型integer是32位(或4字节)，为了获得数组的大小，您应该执行以下操作：

1 2	int array[10]; int sizeOfArray = sizeof(array)/sizeof(int);

1 2	int a[10]; int size = (*(&a+1)-a) ;

有关详细信息，请参阅在这里这里也是。

您可以使用&操作符。以下是源代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

#include<stdio.h>
#include<stdlib.h>
int main(){

int a[10];

int *p;

printf("%p
", (void *)a);
printf("%p
", (void *)(&a+1));
printf("---- diff----
");
printf("%zu
", sizeof(a[0]));
printf("The size of array a is %zu
", ((char *)(&a+1)-(char *)a)/(sizeof(a[0])));

return 0;
};

这是样本输出

1
2
3
4
5

1549216672
1549216712
---- diff----
4
The size of array a is 10

例子

1
2
3
4
5
6
7
8
9
10
11
12

#include <stdio.h>

int main() {
int size;
scanf("%d", &size);
int array[size];
printf("%d
", (int) (sizeof(array) / sizeof(int)));
printf("%d
", (int) (sizeof(array) / sizeof(array[0])));
return 0;
}