“你这是搬起石头砸自己的脚。”

C 'native'数组不存储它们的大小。因此，建议将数组的长度保存在单独的变量/const中，并在传递数组时传递它，即:

#define MY_ARRAY_LENGTH   15
int myArray[MY_ARRAY_LENGTH];

如果你正在编写c++，无论如何你都应该避免本机数组(除非你不能，在这种情况下，小心脚下)。如果你正在编写c++，请使用STL的“vector”容器。“与数组相比，它们提供了几乎相同的性能”，而且它们更有用!

// 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/

如果你正在处理没有作为参数接收的数组，sizeof方式是正确的方式。作为参数发送给函数的数组被视为指针，因此sizeof将返回指针的大小，而不是数组的大小。

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

测试:

#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\n", (int) sizeof(array));
    printSizeOf(array);

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

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

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

输出(64位Linux操作系统):

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

输出(32位windows操作系统):

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

每个人都在使用的宏ARRAYELEMENTCOUNT(x)的计算结果不正确。实际上，这只是一个敏感的问题，因为你不能有导致“数组”类型的表达式。

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

ARRAYELEMENTCOUNT(p + 1);

实际计算结果为:

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

而

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

ARRAYELEMENTCOUNT(p + 1);

它正确地计算为:

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

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

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

在一天结束的时候，在这个特殊的例子中，错误并不重要(所以我只是在浪费大家的时间;Huzzah !)，因为你没有数组类型的表达式。但是我认为关于预处理器评估的微妙之处是很重要的。

一个更优雅的解决方案是

size_t size = sizeof(a) / sizeof(*a);

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

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

/* 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\n", 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;
}

“你这是搬起石头砸自己的脚。”

C 'native'数组不存储它们的大小。因此，建议将数组的长度保存在单独的变量/const中，并在传递数组时传递它，即:

#define MY_ARRAY_LENGTH   15
int myArray[MY_ARRAY_LENGTH];

如果你正在编写c++，无论如何你都应该避免本机数组(除非你不能，在这种情况下，小心脚下)。如果你正在编写c++，请使用STL的“vector”容器。“与数组相比，它们提供了几乎相同的性能”，而且它们更有用!

// 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/