C语言02 - 指针运算、数组与指针、指针变量名、指针与函数参数、指针函数、函数指针、二级指针

1. 指针的定义，指针的运算

    int main(){
    int a = 10;
    int *p;
    p = &a;
    *p = *p + 10;
    printf("p : %d , a:%d\n", *p, a);
    int y = 1 + *p;
    printf("y : %d\n",y);
    *p += 1;
    printf("p : %d , a:%d\n", *p, a);
    // p : 20, a : 20
    // y : 21
    // p : 21, a : 21

    (*p)++;
    printf("p : %d , a:%d, p address:%#x \n", *p, a,p);
    *p++; // 先进行p++ 在进行 *p
    printf("p : %d , a:%d, p address:%#x \n", *p, a,p);
    system("pause");
    // p : 22 , a:22, p address:0x5bf878
    // p: -858993460, a : 22, p address : 0x5bf87c
    // 从0x5bf878 到 0x5bf87c 刚好4个字节
    // 说明：*p++  对地址进行了位移
    // 指针运算： 
    // *p 代表是它所指的地址上面的值的运算
    //  p++ 是p 指针变量++，结果就是：p指向它的下一个地址
    return 0;
}

2. 数组与指针

int main(){
    // 数组名，就是数组的首地址
    int a[5];
    int *p = a;
    int i;
    printf("%#x\n",a);
    // a+5 ,表示a移动到数组的第5个位置（5个int的长度，就是 5 *4 个字节）
    for ( i = 0; p < a + 5; p++)
    {
        *p = i;
        i++;
    }

    // ================================================================

    int b[5] = {1,2,3,4,5};
    int *z;
    z = b;

    z = z + 1;
    printf("z: %d\n",*z);  // z:2

    // 以下等价
    // b[i] == *(z + 1);
    // &b[i] == b + i;
    // z + i == &b[i] == b+i;

    system("pause");
    return 0;
}

3. 指针变量名

int main(){
    int a = 9;
    int *p = &a;
    // p 是一个指针变量，
    // *p 是从p指针变量里面取出一个int 型数据
    // p 类型 int *;
    // *p 类型 int;

    char *cp = "Hello";
    printf("sizeof(p):%d , sizeof(cp):%d \n", sizeof(p),sizeof(cp));
    // sizeof(p):4 , sizeof(cp):4
    // 都是4，为什么相等，p和cp都是指针变量，指针变量都是用来存地址的，
    // 而我们C语言中地址占4个字节，所以不管什么类型的指针，他都是用来存
    // 4个字节的地址的。

    // ==============================================================

    // 既然都是占用4个字节，为什么会有int类型 和char类型
    // 因为我们在对指针进行运算的时候，

    printf("p address:%#x\n",p);
    p++;
    printf("p address:%#x\n", p);

    printf("cp address:%#x\n", cp);
    cp++;
    printf("cp address:%#x\n", cp);

    // p address : 0x109fb0c
    // p address : 0x109fb10   
    // cp address : 0xca5ae0
    // cp address : 0xca5ae1

    // 0x109fb10 -  0x109fb0c = 4
    // 0xca5ae1 - 0xca5ae0 =1

    // 也就告诉我们++会根据你所指的变量的类型的不同而不同
    // ++ 运算是对内存地址的一种迁移，如果指针指的是int型，移动的就是4个字节
    // 如果指的是char型，移动的就是1个字节

    system("pause");
    return 0;
}

4. 指针与函数参数

void swap(int c, int  d){
    printf("c address:%#x,d address:%#x \n", &c, &d);
    int temp;
    temp = c;
    c = d;
    d = temp;
}

// 形参的修改不能带来实参的修改
// 将 a b 的地址copy给了形参，然后将这个copy的地址进行了切换，而地址所指的值是没有变的
void swap2(int *a, int *b){

    int *temp;
    temp = a;   // a address 给了temp
    a = b;      // a的地址变成了b的地址
    b = temp;   // b的地址变成了a的地址
    printf("a address:%#x,b address:%#x \n", a, b);// 这里是二级指针，不要写成&a,&b

}

void swap3(int *a, int *b){
    printf("a address:%#x,b address:%#x \n", a, b);
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;
}

int main(){
    //int a, b;
    //a = 10;
    //b = 5;
    //printf("a address:%#x,b address:%#x \n",&a,&b);
    //swap(a,b);
    //printf("a = %d, b=%d\n",a,b);
    //  a address : 0x73fe58, b address : 0x73fe4c
    //  c address : 0x73fd74, d address : 0x73fd78
    //  a = 10, b = 5

    // =======================================

    int a, b;
    a = 10;
    b = 5;
    printf("a address:%#x,b address:%#x \n", &a, &b);
    swap2(&a, &b);
    printf("a = %d, b=%d\n", a, b);
    system("pause");

    //  a address:0x26fd08,b address:0x26fcfc
    //  a address : 0x26fcfc, b address : 0x26fd08
    //  a = 10, b = 5
    //  还是不行，为什么呢？

    // =======================================

    //int a, b;
    //a = 10;
    //b = 5;
    //printf("a address:%#x,b address:%#x \n", &a, &b);
    //swap3(&a, &b);
    //printf("a = %d, b=%d\n", a, b);
    //system("pause");
    return 0;
}

5. 指针数组 ,数组指针

void sort(char *name[], int n);

int main(){
    // 指针数组： 是一个数组，数组里面存储的是指针类型的变量
    char *name[] = {"hello","zeking","learning","jNI"};
    int i, n = 4;
    sort(name,n);
    for (i = 0; i < n; i++){
        printf("%s\n",name[i]);
    }
    //  hello
    //  jNI
    //  learning
    //  zeking

    // ========================================
    // 数组指针： 是一个指针，这个指针指向的是一个数组的首地址
    // p2指向的是 一个数组，一个有5个元素的数组 的指针变量
    char(*p2)[5];
    // p2 是一个指针变量名

    system("pause");
    return 0;
}

void sort(char *name[], int n){
    char *temp;
    int i,j;
    for (i = 0; i < n; i++){
        for (j = 0; j < n - 1; j++){
            if (strcmp(name[j],name[j+1])>0){
                temp = name[j];
                name[j] = name[j + 1];
                name[j + 1] = temp;
            }
        }
    }
}

6. 二级指针

// 二级指针，存的内容是一个一级指针的地址
// p 的值就是 p 这个变量，这个变量保存的是a 的地址
// *p 运算，得到的就是a 的值
// *p2 运算，得到的就是p的值
// **p2 运算，得到的就是 p的值的 *运算得到的值 a；
int main(){
    int a = 100;
    int *p;
    p = &a;

    int **p2;
    p2 = &p;

    int * * p3;


    system("pause");
    return 0;
}