计算数组的sizeof的大小

#include 
int main()
{                                
                             
  int a[] = {1,2,3,4};

  printf("%d\n", sizeof(a));//16

  printf("%d\n", sizeof(a + 0));//8

  //a + 0 的含义：在C语言中，数组名 a 在表达式中会退化为指向其第一个元素的指针（也就是第一个元素的地址）。

// 因此，a + 0 等价于 &a[0]，即指向数组第一个元素的指针，类型是 int *。 sizeof(a + 0) 的含义： a +  0 是一个指针表达式，类型是 int *。sizeof(a + 0) 计算的是指针的大小，而不是数组的大小。

//指针的大小取决于系统的架构： 在32位系统上，指针的大小通常是4字节。 在64位系统上，指针的大小通常是8字节。
//sizeof(a) 的区别：如果直接使用 sizeof(a)，计算的是整个数组的大小。因为 a 是一个包含4个 int 的数组，每个 int 通常是4字节，
//所以 sizeof(a) 的值是 4 * 4 = 16 字节。





printf("%d\n", sizeof(*a));//4
// a 的类型：
// a 是一个数组，定义为 int a[4]，表示它是一个包含4个 int 类型元素的数组。
// *a 的含义：在C语言中，数组名 a 在表达式中会退化为指向其第一个元素的指针，即 a 等价于 &a[0]。
//  因此， *a 等价于 a[0]，即数组的第一个元素，类型是 int。
// sizeof(*a) 的含义： *a 的类型是 int。sizeof(*a) 计算的是 int 类型的大小。在大多数系统中，int 的大小是4字节。




      printf("%d\n", sizeof(a + 1));//8
// 数组 a 的类型：a 是一个包含 4 个整数的数组，类型是 int[4]。

// a +1 的含义：a 在表达式中会退化为指向数组第一个元素的指针，即 int *类型。因此，a + 1 是指向数组第二个元素的指针，类型仍然是 int *。

//sizeof(a + 1) 的含义：a +1 是一个指针，sizeof(a + 1) 计算的是指针的大小，而不是数组的大小。
//在大多数系统上，指针的大小是 8 字节（64 位系统）或 4 字节（32 位系统）。

//输出结果：sizeof(a + 1) 的值取决于系统的指针大小。在 64 位系统上，输出通常是 8；在 32 位系统上，输出通常是 4。

// 总结 sizeof(a + 1) 计算的是指针的大小，而不是数组的大小。因此，输出结果取决于系统的指针大小。

//如果你想要计算整个数组的大小，应该直接使用 sizeof(a)，而不是 sizeof(a + 1)。





 printf("%d\n", sizeof(a[1])); // 4

// a[1] 的含义：a 是一个数组，a[1] 是数组的第二个元素，值为 2。a[1] 的类型是 int。

//sizeof(a[1]) 的含义：sizeof(a[1]) 计算的是 a[1] 这个元素所占用的内存大小。因为 a[1] 是 int 类型，所以 sizeof(a[1]) 计算的是 int 的大小。

//int 的大小：在大多数现代系统上，int 的大小是 4 字节（32 位）。输出结果 sizeof(a[1]) 的值是 4，因为 int 类型通常占用 4 个字节。

printf("%d\n", sizeof(&a)); // 8
//&a 的含义：a 是一个数组，类型是 int[4]（包含 4 个 int 元素的数组）。&a 是数组 a 的地址，类型是 int(*)[4]，即指向 int[4] 的指针。

//sizeof(&a) 的含义： sizeof(&a) 计算的是指针 &a 的大小。

//指针的大小与系统的架构有关：在 32 位系统上，指针的大小通常是 4 字节。在 64 位系统上，指针的大小通常是 8 字节。
//sizeof(&a) 的结果：无论 &a 指向的是什么类型的数据（这里是 int[4]），sizeof(&a) 始终计算的是指针本身的大小，而不是指针所指向的数据的大小。










printf("%d\n", sizeof(*&a)); // 16

// &a 的含义：

//  a 是一个数组，类型是 int[4]（包含 4 个 int 元素的数组）。

//  &a 是数组 a 的地址，类型是 int(*)[4]，即指向 int[4] 的指针。

// *&a 的含义：

// *&a 是对指针 &a 解引用，得到的是数组 a 本身。

//     因此， *&a 的类型是 int[4]。

//     sizeof(*&a) 的含义：

//     sizeof(*&a) 计算的是数组 a 的大小。

//         数组 a 包含 4 个 int 元素，每个 int 通常占用 4 字节。

//             因此，sizeof(*&a) 的值是 4 *
//     sizeof(int)。

//     sizeof(int) 的大小：

// 在大多数现代系统上，int 的大小是 4 字节。

// 计算过程 sizeof(*&a) = sizeof(a) = 4 * sizeof(int) = 4 * 4 = 16
















    printf("%d\n", sizeof(&a + 1)); // 8

// a 的类型：a 是一个数组，定义为 int a[4]，表示它是一个包含4个 int 类型元素的数组。

//&a 的含义：&a 是数组 a 的地址，类型是 int(*)[4]，即指向整个数组的指针。

//&a + 1 的含义：&a 是指向数组 a 的指针，类型是 int(*)[4]。

//对指针进行 + 1 操作时，指针会根据其指向的类型进行偏移。

//由于 &a 的类型是 int(*)[4]，即指向一个包含4个 int 元素的数组，因此 &a + 1 会指向下一个 int[4] 数组的起始位置(偏移了一个数组的大小)。

//换句话说， &a + 1 是一个指向数组 a 末尾之后的位置的指针，类型仍然是 int(*)[4]。

// sizeof(&a + 1) 的含义：

//&a + 1 是一个指针，类型是 int(*)[4]。

//sizeof(&a + 1) 计算的是指针的大小，而不是数组的大小。

//指针的大小取决于系统的架构：

//在32位系统上，指针的大小通常是4字节。

// 在64位系统上，指针的大小通常是8字节。




printf("%d\n", sizeof(&a[0])); // 8

//  a[0] 的含义：a 是一个数组，定义为 int a[4]，表示它是一个包含4个 int 类型元素的数组。

// a[0] 是数组 a 的第一个元素，类型是 int。

// &a[0] 的含义：

// &a[0] 是数组 a 的第一个元素的地址，类型是 int*。

// sizeof(&a[0]) 的含义：

// &a[0] 是一个指针，类型是 int*。

// sizeof(&a[0]) 计算的是指针的大小，而不是 int 的大小。

// 指针的大小取决于系统的架构：

// 在32位系统上，指针的大小通常是4字节。

// 在64位系统上，指针的大小通常是8字节。





printf("%d\n", sizeof(&a[0] + 1)); // 8

// a[0] 的含义：a 是一个数组，定义为 int a[4]，表示它是一个包含4个 int 类型元素的数组。

// a[0] 是数组 a 的第一个元素，类型是 int。

//&a[0] 的含义：&a[0] 是数组 a 的第一个元素的地址，类型是 int *。

// &a[0] +1 的含义：&a[0] 是指向数组 a 的第一个元素的指针，类型是 int *。

//     对指针进行 + 1 操作时，指针会根据其指向的类型进行偏移。

//由于 &a[0] 的类型是 int *，即指向 int 的指针，因此 &a[0] + 1 会指向数组 a 的第二个元素（即 a[1]），类型仍然是 int *。

//sizeof(&a[0] + 1) 的含义：&a[0] +1 是一个指针，类型是 int *。

//sizeof(&a[0] + 1) 计算的是指针的大小，而不是 int 的大小。

//指针的大小取决于系统的架构：在32位系统上，指针的大小通常是4字节。在64位系统上，指针的大小通常是8字节。

// 总结:&a[0] + 1 是一个指针，类型是 int *。sizeof(&a[0] + 1) 计算的是指针的大小，而不是 int 的大小。
}