C 如何找到'；尺寸'；（指向数组的指针）？

首先，这里有一些代码：

int main() 
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", sizeof(days));
    printf("%u\n", sizeof(ptr));

    return 0;
}

---

有没有办法找出

ptr

指向的数组的大小（而不是只给出它的大小，在32位系统中是四个字节）

不，你不能。编译器不知道指针指向什么。有一些技巧，比如用已知的带外值结束数组，然后计算大小直到该值，但这不是使用

sizeof（）

另一个技巧是所提到的，那就是把尺寸藏在某个地方。例如，如果要动态分配数组，请分配一个大于所需整数的块，将大小隐藏在第一个整数中，并返回

ptr+1

作为指向数组的指针。需要大小时，减小指针并查看隐藏的值。请记住从一开始就释放整个块，而不仅仅是数组。

答案是“不”

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

struct Array
{
    int length;

    double *array;
};

typedef struct Array Array;

Array* NewArray(int length)
{
    /* Allocate the memory for the struct Array */
    Array *newArray = (Array*) malloc(sizeof(Array));

    /* Insert only non-negative length's*/
    newArray->length = (length > 0) ? length : 0;

    newArray->array = (double*) malloc(length*sizeof(double));

    return newArray;
}

void SetArray(Array *structure,int length,double* array)
{
    structure->length = length;
    structure->array = array;
}

void PrintArray(Array *structure)
{       
    if(structure->length > 0)
    {
        int i;
        printf("length: %d\n", structure->length);
        for (i = 0; i < structure->length; i++)
            printf("%g\n", structure->array[i]);
    }
    else
        printf("Empty Array. Length 0\n");
}

int main()
{
    int i;
    Array *negativeTest, *days = NewArray(5);

    double moreDays[] = {1,2,3,4,5,6,7,8,9,10};

    for (i = 0; i < days->length; i++)
        days->array[i] = i+1;

    PrintArray(days);

    SetArray(days,10,moreDays);

    PrintArray(days);

    negativeTest = NewArray(-5);

    PrintArray(negativeTest);

    return 0;
}

C程序员所做的是将数组的大小存储在某个地方。它可以是结构的一部分，或者程序员可以欺骗一点，并且<代码> MalCube（）/C++ >存储更多的内存，以便在数组开始之前存储一个长度值。您需要存储其他人提到的数组大小，或者可能需要构建一个处理添加、删除、计数、，不幸的是，C并没有像C++那样做这件事，因为基本上必须为每个存储的不同类型的数组建立它，如果你需要管理的数组类型繁多，那么这是麻烦的。

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

struct Array
{
    int length;

    double *array;
};

typedef struct Array Array;

Array* NewArray(int length)
{
    /* Allocate the memory for the struct Array */
    Array *newArray = (Array*) malloc(sizeof(Array));

    /* Insert only non-negative length's*/
    newArray->length = (length > 0) ? length : 0;

    newArray->array = (double*) malloc(length*sizeof(double));

    return newArray;
}

void SetArray(Array *structure,int length,double* array)
{
    structure->length = length;
    structure->array = array;
}

void PrintArray(Array *structure)
{       
    if(structure->length > 0)
    {
        int i;
        printf("length: %d\n", structure->length);
        for (i = 0; i < structure->length; i++)
            printf("%g\n", structure->array[i]);
    }
    else
        printf("Empty Array. Length 0\n");
}

int main()
{
    int i;
    Array *negativeTest, *days = NewArray(5);

    double moreDays[] = {1,2,3,4,5,6,7,8,9,10};

    for (i = 0; i < days->length; i++)
        days->array[i] = i+1;

    PrintArray(days);

    SetArray(days,10,moreDays);

    PrintArray(days);

    negativeTest = NewArray(-5);

    PrintArray(negativeTest);

    return 0;
}

对于静态数组（如示例中的数组），有一个常用宏用于获取大小，但不建议使用它，因为它不会检查参数是否确实是静态数组。该宏用于实际代码，例如Linux内核头，尽管它可能与下面的略有不同：

#if !defined(ARRAY_SIZE)
    #define ARRAY_SIZE(x) (sizeof((x)) / sizeof((x)[0]))
#endif

int main()
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", ARRAY_SIZE(days));
    printf("%u\n", sizeof(ptr));
    return 0;
}

你可以在谷歌上搜索一些原因来警惕这样的宏。小心点

---

如果可能的话，C++的STDLIB，比如向量，它更安全，更容易使用。对于这个特定的例子，

< P>，是的，如果你使用Type Debug（见下文）。当然，如果你这样做，你也可以使用SIZEOF_天，因为你知道指针指向什么

如果您有一个（void*）指针（由malloc（）或类似的函数返回），那么，不，无法确定指针指向的数据结构，因此也无法确定其大小

#include <stdio.h>

#define NUM_DAYS 5
typedef int days_t[ NUM_DAYS ];
#define SIZEOF_DAYS ( sizeof( days_t ) )

int main() {
    days_t  days;
    days_t *ptr = &days; 

    printf( "SIZEOF_DAYS:  %u\n", SIZEOF_DAYS  );
    printf( "sizeof(days): %u\n", sizeof(days) );
    printf( "sizeof(*ptr): %u\n", sizeof(*ptr) );
    printf( "sizeof(ptr):  %u\n", sizeof(ptr)  );

    return 0;
} 

---

有C++模板的干净的解决方案，不使用<强> siZeFo（）< <强> >。以下getSize（）函数返回任何静态数组的大小：

#include <cstddef>

template<typename T, size_t SIZE>
size_t getSize(T (&)[SIZE]) {
    return SIZE;
}

---

正如所有正确答案所述，您无法仅从数组的衰减指针值获得此信息。如果衰减指针是函数接收到的参数，则必须以其他方式提供原始数组的大小，以便函数知道该大小

这里有一个不同于目前提供的建议，它将起作用：将指针传递到数组。这个建议与C++风格的建议类似，除了C不支持模板或引用：

#define ARRAY_SZ 10

void foo (int (*arr)[ARRAY_SZ]) {
    printf("%u\n", (unsigned)sizeof(*arr)/sizeof(**arr));
}

但是，对于您的问题来说，这个建议有点傻，因为定义函数是为了准确地知道传入的数组的大小（因此，根本不需要在数组上使用sizeof）。不过，它的作用是提供某种类型的安全性。它将禁止您传入不需要的大小的数组

int x[20];
int y[10];
foo(&x); /* error */
foo(&y); /* ok */

如果函数应该能够对任意大小的数组进行操作，那么您必须将该大小作为附加信息提供给函数

 #define array_size 10

 struct {
     int16 size;
     int16 array[array_size];
     int16 property1[(array_size/16)+1]
     int16 property2[(array_size/16)+1]
 } array1 = {array_size, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

 #undef array_size

数组大小正在传递给size变量：

#define array_size 30

struct {
    int16 size;
    int16 array[array_size];
    int16 property1[(array_size/16)+1]
    int16 property2[(array_size/16)+1]
} array2 = {array_size};

#undef array_size

用途是：

void main() {

    int16 size = array1.size;
    for (int i=0; i!=size; i++) {

        array1.array[i] *= 2;
    }
}

---

我解决这个问题的方法是将数组的长度保存到结构数组中，作为关于数组的元信息

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

struct Array
{
    int length;

    double *array;
};

typedef struct Array Array;

Array* NewArray(int length)
{
    /* Allocate the memory for the struct Array */
    Array *newArray = (Array*) malloc(sizeof(Array));

    /* Insert only non-negative length's*/
    newArray->length = (length > 0) ? length : 0;

    newArray->array = (double*) malloc(length*sizeof(double));

    return newArray;
}

void SetArray(Array *structure,int length,double* array)
{
    structure->length = length;
    structure->array = array;
}

void PrintArray(Array *structure)
{       
    if(structure->length > 0)
    {
        int i;
        printf("length: %d\n", structure->length);
        for (i = 0; i < structure->length; i++)
            printf("%g\n", structure->array[i]);
    }
    else
        printf("Empty Array. Length 0\n");
}

int main()
{
    int i;
    Array *negativeTest, *days = NewArray(5);

    double moreDays[] = {1,2,3,4,5,6,7,8,9,10};

    for (i = 0; i < days->length; i++)
        days->array[i] = i+1;

    PrintArray(days);

    SetArray(days,10,moreDays);

    PrintArray(days);

    negativeTest = NewArray(-5);

    PrintArray(negativeTest);

    return 0;
}

#包括
#包括
结构数组
{
整数长度；
双*阵列；
};
typedef结构数组；
数组*新数组（整数长度）
{
/*为结构数组分配内存*/
Array*newArray=（Array*）malloc（sizeof（Array））；
/*仅插入非负长度的*/
新数组->长度=（长度>0）？长度：0；
newArray->array=（double*）malloc（length*sizeof（double））；
返回新数组；
}
void SetArray（数组*结构，整数长度，双*数组）
{
结构->长度=长度；
结构->数组=数组；
}
void printary（数组*结构）
{       
如果（结构->长度>0）
{
int i；
printf（“长度：%d\n”，结构->长度）；
对于（i=0；ilength；i++）
printf（“%g\n”，结构->数组[i]）；
}
其他的
printf（“空数组。长度0\n”）；
}
int main（）
{
int i；
数组*否定测试，*天=新数组（5）；
双倍多天[]={1,2,3,4,5,6,7,8,9,10}；
对于（i=0；ilength；i++）
天数->数组[i]=i+1；
打印阵列（天）；
SetArray（天、10天、更多天）；
打印阵列（天）；
negativeTest=NewArray（-5）；
打印阵列（负片测试）；
返回0；
}

---

但是，您必须注意设置要存储的数组的正确长度，因为正如我们的朋友大量解释的那样，无法检查此长度。

不，您不能使用

sizeof（ptr）

来查找

ptr

所指向的数组的大小

不过，如果您想将长度存储在额外的空间中，则分配额外的内存（大于数组的大小）会很有帮助

int main() 
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", sizeof(days));
    printf("%u\n", sizeof(ptr));

    return 0;
}

天数[]的大小为20，这是元素数*其数据类型的大小。 而不管指针指向什么，指针的大小都是4。

---

因为指针通过存储地址指向其他元素

没有神奇的解决办法。C不是一种反思性语言。对象不会自动知道它们是什么

但你有很多选择：

int main() 
{
    int days[] = {1,2,3,4,5};
    int *ptr = days;
    printf("%u\n", sizeof(days));
    printf("%u\n", sizeof(ptr));

    return 0;
}

int days[] = { /*length:*/5, /*values:*/ 1,2,3,4,5 };
int *ptr = days + 1;
printf("array length: %u\n", ptr[-1]);
return 0;

typedef struct intArr {
    int size;
    int* arr; 
} intArr_t;

int main() {
    intArr_t arr;
    arr.size = 6;
    arr.arr = (int*)malloc(sizeof(int) * arr.size);

    for (size_t i = 0; i < arr.size; i++) {
        arr.arr[i] = i * 10;
    }

    return 0;
}