int i = 7, j = 9;
float k = 12.6f;
int *mypoint1, *mypoint2;  // 指向整型变量的指针
float *pm3;                 // 指向实型变量的指针
char *pm4;                  // 指向字符型变量的指针

mypoint1 = &i;  // mypoint1 指向 i
mypoint2 = &j;  // mypoint2 指向 j

int a = 100, b = 200;
int *p1, *p2;
p1 = &a;   // p1 指向 a
p2 = &b;   // p2 指向 b
int *p3 = &a;  // 定义时初始化

printf("%d, %d\n", a, b);       // 100, 200
printf("%d, %d\n", *p1, *p2);   // 100, 200，*p1 代表 a，*p2 代表 b

// 交换两个指针指向的值
int *pmax, *pmin, *p, a = 5, b = 8;
pmax = &a;
pmin = &b;
if(a < b) {
    p = pmax;
    pmax = pmin;  // pmax 指向大的值
    pmin = p;     // pmin 指向小的值
}
printf("max = %d, min = %d\n", *pmax, *pmin);  // max = 8, min = 5

void swap(int *pdest1, int *pdest2) {
    int temp;
    temp = *pdest1;       // 取 pdest1 指向的值
    *pdest1 = *pdest2;    // 赋值给 pdest1 指向的变量
    *pdest2 = temp;       // 赋值给 pdest2 指向的变量
}

int main() {
    int a = 5, b = 6;
    int *p1 = &a, *p2 = &b;
    if(a < b) swap(p1, p2);
    printf("a=%d, b=%d\n", a, b);  // a=6, b=5
    return 0;
}

int a[5];
int *p;
p = &a[0];  // 等价于 p = a;  数组名就是首地址
// 定义时初始化
int *p = &a[0];  // 等价于 int *p = a;

int a[5] = {12, 14, 20, 18, 50};
int *p;

// 方法1: 下标法
for(int i = 0; i < 5; i++)
    printf("%d\n", a[i]);

// 方法2: 地址法
for(int i = 0; i < 5; i++)
    printf("%d\n", *(a + i));

// 方法3: 指针法（最快）
for(p = a; p < (a + 5); p++)
    printf("%d\n", *p);

// 实参用数组名，形参用指针变量
void changevalue(int *p) {
    *(p + 2) = 888;  // 等价于给 a[2] 赋值 888
}

int main() {
    int a[5] = {85, 70, 98, 92, 78};
    changevalue(a);  // 传递数组首地址
    return 0;
}

int a[3][4];
int *p;
p = (int *)(a + 1);  // 第 1 行首地址
*p = 56;              // 相当于 a[1][0] = 56
p++;
*p = 78;              // 相当于 a[1][1] = 78

// 指针数组：适合指向若干字符串
const char *pName[] = {"C++", "Java", "Python", "Go", "CSharp"};

// 交换指针数组中的指针
const char *ptmp;
ptmp = pName[0];
pName[0] = pName[1];  // pName[0] 指向 "Java"
pName[1] = ptmp;       // pName[1] 指向 "C++"

char mystr[] = "I love China";  // 字符串复制到数组中
printf("%s\n", mystr);

const char *pmystr = "I love China";  // 指针指向字符串常量
printf("%s\n", pmystr);

// 下标法
char a[] = "I love China!";
char b[100];
for(int i = 0; *(a + i) != '\0'; i++)
    *(b + i) = *(a + i);
*(b + i) = '\0';

// 指针法
char *p1 = a, *p2 = b;
for(; *p1 != '\0'; p1++, p2++)
    *p2 = *p1;
*p2 = '\0';

void copystr(char *from, char *to) {
    while(*from)           // 不遇到 '\0' 就继续
        *to++ = *from++;   // 先赋值再各自后移
    *to = '\0';
}

// 字符数组：不能直接赋值
char str[100];
// str = "I love China!";  // 不允许！
strcpy(str, "I love China!");  // 正确

// 字符指针：可以直接指向
const char *a = "I love China!";
a = a + 7;  // 指针可以改变，现在指向 "China"
printf("%s\n", a);  // China

int max(int x, int y) {
    if(x > y) return x;
    return y;
}

int (*p)(int, int);  // 定义函数指针变量
p = max;             // 将函数入口地址赋给 p
int c = (*p)(5, 19); // 通过函数指针调用，等价于 c = max(5, 19);
// 也可以写成 c = p(5, 19);

int callmax(int x, int y, int (*idfunc)(int, int)) {
    int result = idfunc(x, y);  // 通过函数指针调用
    return result;
}

int main() {
    int c = callmax(5, 19, max);  // 传递函数名
    // 也可以用函数指针变量
    int (*p)(int, int) = max;
    c = callmax(45, 21, p);
    return 0;
}

// 错误示范：返回局部变量地址
int *add(int x, int y) {
    int sum = x + y;
    return ∑  // 致命问题！sum 的内存会被回收
}

// 正确做法：使用全局变量
int sum;  // 全局变量，生存期到程序结束
int *add(int x, int y) {
    sum = x + y;
    return ∑  // 安全
}

int main(int argc, char *argv[]) {
    for(int i = 0; i < argc; i++)
        printf("argv[%d] = %s\n", i, argv[i]);
    return 0;
}

void *pvn = NULL;
int a = 3;
int *p = &a;
float f = 5.6f;
float *pf = &f;

pvn = p;    // 不报错
pvn = pf;   // 不报错
pf = (float *)pvn;  // 强制转换回原类型