int a[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11 };for (int i = 0; i < 3; i++) {	for (int j = 0; j < 4; j++) {		printf("a[%d][%d] : %p\n", i, j, &a[i][j]);	}}

int a[10] = {0};//a是数组首元素地址,&a是数组的地址
int (*p)[10] = a;  //警告:间接级别不同int (*p)[10] = &a; //符合

int main(){	int a[4] = { 1,2,3,4 };	int* p = &a + 1;	printf("%d \n", p[-1]); //指针才有的用法: p[-1] == *(p-1)	return 0;}

int a[3][4] = { 0,1,2,3,4,5,6,7,8,9,10,11 };printf("%d\n", sizeof(a)); //二维数组printf("%d\n", sizeof(a[0][0])); //二维数组第一个元素的第一个元素,即第一个一维数组的第一个元素printf("%d\n", sizeof(a[0]));    //二维数组的第一个元素,是第一个一维数组,没有降维,16printf("%d\n", sizeof(a[0] + 1));  //二维数组的第一个元素+1,即降维成第一个一维数组的首元素地址+1.是第一个一维数组的第二个元素的地址.
printf("%d\n", sizeof(*(a[0]+1)));  //第一个一维数组的第二个元素printf("%d\n", sizeof(a + 1));  //降维成二维数组第一个元素的地址+1,即二维数组第二个元素的地址printf("%d\n", sizeof(*(a+1)));     //二维数组的第二个元素,即第二个一维数组,没有发生降维,16printf("%d\n", sizeof(&a[0] + 1));    //理解1:二维数组的第一个元素即第一个一维数组取地址,需要一维数组降维成指针,才能进行取地址,数组降维成指针后,就是数组的首元素地址,首元素地址再取地址就成了一维数组. (编译器不支持再升维成数组)//理解2:二维数组的第一个元素取地址,二维数组就已经降维成二维数组的首元素地址,元素取地址,则指针对应的类型是二维数组元素的类型,+1就是加一个元素的大小.即得到二维数组的第二个元素的地址. (这种理解更符合编译器行为)
printf("%d\n", sizeof(*(&a[0]+1))); //什么含义？printf("%d\n", sizeof(*a));   //什么含义？printf("%d\n", sizeof(a[3])); //什么含义？

int a[5][5] = { 0 };for (int i = 0; i < 25; i++){	*(&**a + i) = i;}for (int i = 0; i < 25; i++){	printf("%d ", *(&**a + i));}puts("");
int(*p)[4];  //定义一个类型为int[4]的指针变量p = (int(*)[4])a;  //强转只是为了让编译器不警告printf("pa=%p, pb=%p\n", &a[4][2], &p[4][2]);  //问题1printf("%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]); //问题2
//先将指针模拟数组多维访问的方式降维成一维的计算方式: p[4][2] = *(*(p + 4) + 2);//然后将数组物理结构图展开//p所指向的类型是int[4],因此步长是4个int//a本身是数组,不需要降维//编译器会查看元素是否是地址,或者说,默认指针计算就是把元素值当作地址.所以不用当心指针解引用后是指针还是数据的影响.

void func(int(*p)[6],int size) //一维数组,数组元素类型为int[6][7][8]{ }
int main(){	int a[5][6] = { 0 };	func(a,5);	return 0;}

void func(int(*p)[6][7][8],int size)  //一维数组,数组元素类型为int[6][7][8]{ }
int main(){	int a[5][6][7][8] = { 0 };	func(a,5);	return 0;}

void func(int p[][6][7][8],int size)  { }
int main(){	int a[5][6][7][8] = { 0 };	func(a,5);	return 0;}

void func(){ }
int main(){	printf("%p\n", func); //常用	printf("%p\n", &func);	return 0;}

#include<stdio.h>#include<stdlib.h>
void fun1(){}
void fun2(){}
int g_val1;int g_val2;
int g_val3 = 0;int g_val4 = 0;
int main()     {             
  int a1 = 0;  int a2 = 0;  static int a3 = 0;
  puts("栈区增长方向验证:");  printf("stack Area: &a1=%p\n",&a1);  printf("stack Area: &a2=%p\n",&a2);
  puts("堆区增长方向验证:");  int *arr1 = (int*)malloc(sizeof(int)*3);  int *arr2 = (int*)malloc(sizeof(int)*3);  printf("heap Area: arr1=%p\n",arr1);  printf("heap Area: arr2=%p\n",arr2);
  puts("未初始化数据区:");  printf("uninitialized data Area: %p\n",&g_val1);  printf("uninitialized data Area: %p\n",&g_val2);    puts("已初始化数据区:");  printf("initialized data Area: %p\n",&g_val3);  printf("initialized data Area: %p\n",&g_val4);  printf("static data Area: %p\n",&a3);
  puts("常量区:");  const char *str = "hello world!";  printf("constant Area: %p\n",str);
  puts("代码区:");  printf("main addr: %p\n",main);  printf("code Area: fun1=%p\n",fun1);  printf("code Area: fun2=%p\n",fun2);  //在前面的先注册
  return 0;    }   

#include <stdio.h>

int Add(int a, int b){    return a+b;}
int main(){    int x = 0xA;    int y = 0xB;    int z = 0;    z = Add(x,y);    return 0;}

#include <vadefs.h>
#define va_start _crt_va_start#define va_arg _crt_va_arg#define va_end _crt_va_end
#endif  /* _INC_STDARG */

//ap ~= arg//va_list == char*//_ADDRESSOF ~= 取地址//v  ~= num//结合下一小节的简单可变参数程序源码
#define _INTSIZEOF(n)          ((sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1))/* 为什么需要对齐在可变参数函数的参数传参过程中,参数会发生整型提升,因此可变参数函数内部要能够对发生整型提升的参数进行正确的提取,需要进行对齐*///计算对齐后n的大小,例如计算char,四字节对齐,则_intsizeof char为4;//四字节对齐,如果size是1,2,3,4,则对齐size都是4. 如果size是5,6,7,8,则对齐size都是8.依次类推//想要一个数是2,4,8,2^n的倍数,只要&上 对应2^n的二进制的1所在左边为全零,保证左边消除尾数,右边全1,保证右边数位不变 这样的数即可. 即& ~(2^n - 1).  这里2^n整体表示2的倍数,如2,4,8,16....

#define _ADDRESSOF(v)          (&(v)) //计算v的地址
#define __crt_va_start_a(ap, v) ((void)(ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v)))// va_start : ap=(char*)&num + intsizeof(num); 
#define __crt_va_arg(ap, t)     (*(t*)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)))//1.ap先指向下一个可变参数:ap += _intsizeof(t)//2.通过ap找到上一个可变参数的地址: ap - _intsizeof(t)//3.解引用,获取上一个可变参数的值: *(t*)ap


#define __crt_va_end(ap)        ((void)(ap = (va_list)0))// 将指针置为无效

va_list arg; //定义一个指向可变参数的指针变量

typedef char* va_list;

void va_start(va_list arg_ptr,prev_param);//(ANSI version)//prev_param是可变参数部分的前一个参数,(不需要确定类型,最终会交给intsizeof计算)

type va_arg( va_list arg_ptr, type ); //

#include <stdio.h>#include <stdarg.h>
int FindMax(int num, ...){    va_list arg;    va_start(arg, num);    int max = 0;    max = va_arg(arg, int);    for (int i = 0; i < num - 1; i++)    {        int cur = va_arg(arg, int);        if (cur > max)        {            max = cur;        }    }    va_end(arg);
    return max;}
int main(){    int max = FindMax(5,0x11,0x21,0x31,0x41,0x51);    printf("max = %d\n", max);    return 0;}