C 数组、指针和Sizeof关系

我了解到，我们可以使用索引I处数组元素的地址作为

&A[I]

或简单地作为

A+I

并获得价值

A[i]

或

*（A+i）

其中，

A

是一个数组，

i

表示索引。 让我们假设

inta[]={1,2,3}

当我使用
sizeof（*A）
时，我得到值
4
，现在当我使用
sizeof（A）
时，我必须得到第一个元素的
地址值的大小，为什么我得到整个数组的大小为
12
。
我是一个初学者，很困惑，请引导。
当您调用
sizeof（a）
时，您得到的数组大小如n.m所说。但是，如果将数组初始化为：

    int *A = new int[3];
    A[0] = 1;
    A[1] = 2;
    A[2] = 3;
    cout << sizeof(A) << endl;

int*A=新的int[3]；
A[0]=1；
A[1]=2；
A[2]=3；
cout当您调用
sizeof（A）
时，您会得到n.m所说的数组大小。但是，如果将数组初始化为：

    int *A = new int[3];
    A[0] = 1;
    A[1] = 2;
    A[2] = 3;
    cout << sizeof(A) << endl;

int*A=新的int[3]；
A[0]=1；
A[1]=2；
A[2]=3；
库特
当我使用sizeof（*A）时，我得到值4

这只是数组中第一个元素的大小，即
sizeof（*A）
与
sizeof（*（&A[0]）
相同


现在，当我使用sizeof（A）时，我必须得到第一个元素的地址值的大小，为什么我得到整个数组的大小为12

您已将
A
声明为

int A[]={1,2,3};

现在，问自己一个简单的问题-
什么是
？永远不要用
数组
以外的任何东西来解决问题。简而言之，您可以获得整个数组的大小（以字节为单位）。这里有3个元素，每个元素占用4个字节

已添加

我必须得到地址值的大小

这应该是
sizeof（&A）
，它是A地址的大小，在许多系统中通常是8字节

int A[]={1,2,3};

当我使用sizeof（*A）时，我得到值4

这只是数组中第一个元素的大小，即
sizeof（*A）
与
sizeof（*（&A[0]）
相同


现在，当我使用sizeof（A）时，我必须得到第一个元素的地址值的大小，为什么我得到整个数组的大小为12

您已将
A
声明为

int A[]={1,2,3};

现在，问自己一个简单的问题-
什么是
？永远不要用
数组
以外的任何东西来解决问题。简而言之，您可以获得整个数组的大小（以字节为单位）。这里有3个元素，每个元素占用4个字节

已添加

我必须得到地址值的大小

这应该是
sizeof（&A）
，它是A地址的大小，在许多系统中通常是8字节

int A[]={1,2,3};

A
是一个
数组
，
数组不是指针
。打印
sizeof（*A）
时，它会打印
4
，因为
*A
表示数组中大小为
4
的第一个元素

sizeof（A）
结果不会产生
4
，因为
A
不是
指针
A
是一个
数组
，
array
表示元素的集合，每个元素需要
4个
字节

A[i] == *(A+i)


sizeof（A[i]）=>4，因为
A[0]
是一个整数

sizeof（*A）=>4
，因为
*A
表示起始地址处的值，需要4个字节来存储
sizeof（A）=>12字节
，而不是4字节，因为A不是指针
sizeof（&A[0]）=>4个字节
，因为
&A[0]
产生地址，任何地址的大小都是
4个字节


A
是一个
数组
，
数组不是指针
。打印
sizeof（*A）
时，它会打印
4
，因为
*A
表示数组中大小为
4
的第一个元素

sizeof（A）
结果不会产生
4
，因为
A
不是
指针
A
是一个
数组
，
array
表示元素的集合，每个元素需要
4个
字节

A[i] == *(A+i)


sizeof（A[i]）=>4，因为
A[0]
是一个整数

sizeof（*A）=>4
，因为
*A
表示起始地址处的值，需要4个字节来存储
sizeof（A）=>12字节
，而不是4字节，因为A不是指针
sizeof（&A[0]）=>4个字节
，因为
&A[0]
产生地址，任何地址的大小都是
4个字节

“当我使用sizeof（A）时，我必须得到地址值的大小”不，你应该得到A的大小。因为A是一个数组，你得到的是数组的大小。因为&A[I]与（A+I）相同，所以如果我使用sizeof（A），我必须得到指向数组第一个元素的地址的容量，希望您了解该语言的规则，如果您说
sizeof（A）
，您将得到
A
的大小。不是
（A+0）
的大小，也不是
和*A
的大小。如果你假设A总是与A+0等相同，那么你就错了。
如果你假设A总是与A+0相同
否，我假设A
A
为
&A[0]
&A[0]
在这种情况下与
A+0
相同。“当我使用sizeof（A）时，我必须得到地址值的大小”否，你应该得到A的大小。因为A是一个数组，你就得到了数组的大小。因为&A[i]和（A+i）是一样的，所以如果我做sizeof（A），我必须得到指向数组第一个元素的地址容量，希望你理解语言的规则，如果你说
sizeof（A）
，你就得到了
A
的大小。不是
（A+0）
的大小，也不是
和*A
的大小。如果你假设A总是与A+0等相同，那么你就错了。
如果你假设A总是与A+0等相同
不，我假设
A
为
&A[0]
&A[0]
为s