指针

指针

• 指针自增、自减的结果，其实就是由指针指向的数据类型宽度决定的！
• 指针加上或减去一个整数的结果，其实就是指针指向的数据类型宽度决定的！
• 指针求差，得到的结果是整形，其结果和指针指向的数据类型宽度有关！
• 这也就是指针的特点！ 它的运算单位 是数据类型的宽度！
• 指针的运算，是根据所指向的数据类型来的！

以下测试一下：

//指针的宽度
void func(){
    // 编译器决定了指针不能做乘法和除法。
    int *varA;
    varA = (int *)100;
    // 指针自增自减的运算结果，是由指针所指向的数据类型宽度决定的！！！（数据类型：去掉一个 * 看左边）
    varA++;
    printf("%lu 个字节--%d",sizeof(varA),varA);
    
    char*varB;
    varB = (char *)100;
    varB++;
    printf("\n%lu 个字节--%d",sizeof(char),varB);

    char**varC;
    varC = (char**)100;
//    varC++;
    varC = varC + 1;   // + 1 ：自增一次
    printf("\n%lu 个字节--%d",sizeof(char),varC);
    
    int * a = 10;
    int * b = 20;
    
    int * c = a - b;
    // int 的话则为 -10，但是 Int * 则需要 除以数据类型的宽度
    //（-10/4）不足一个数据的宽度则进 1（结果为负数不足一个数据的宽度则进 1，正数不进，猜测的，可以测一测）；
    printf("\n%d",c);//
    a = 100;
    b = 200;
    printf("\n%d",a - b);

    if (a > b) {
        printf("\na > b");
    }else{
        printf("\na <= b");
    }
}

对应的打印结果如下：

8 个字节--104
1 个字节--101
1 个字节--108
2
-25
a <= b

另外也可以看出，指针在 64 位 CPU 中，占 64个 Bit,即 8 Byte，int 为 4个字节，char 为 1 个字节。

指针反汇编：

void func3 (){
int *a;
int b = 10;
a = &b;
}

指针反汇编

C 语言数组访问

遍历访问:

void func2(){
    // int *arrp = array[0] == array (数组即首元素的地址)
    int array[5] = {1,2,3,4,5};
    int *arrP = array;
    for (int i = 0 ; i < 5; ++i) {
        // 1.
        printf("方法一：%d\n",array[I]);
        // 2.
        printf("方法二：%d\n",*(array+i));// array+i 为地址
        // 3.
        printf("方法三：%d\n\n",*(arrP++));
    }
}

打印结果：

方法一：1
方法二：1
方法三：1

方法一：2
方法二：2
方法三：2

方法一：3
方法二：3
方法三：3

方法一：4
方法二：4
方法三：4

方法一：5
方法二：5
方法三：5

指针的基本用法

• 一级指针：

void func4 (){
char *p;
char c = *p;
}

x8 为空，即p 未赋值，取值崩溃

• 二级指针：

 void func4 (){
    // 1.
//    char *p;
//    char c = *p;
    // 2.
    char **p;
    char c = **p;
}

二级指针取值

void func4 (){
    // 1.
//    char *p;
//    char c = *p;
    
    // 2.
//    char **p;
//    char c = **p;

    // 3.
    char **p;
    char c = *(*(p + 2)+2);
}

image.png

4. 相当于 3 的写法。

void func4 (){
    // 1.
//    char *p;
//    char c = *p;
    
    // 2.
//    char **p;
//    char c = **p;

    // 3.
    char **p;
//    char c = *(*(p + 2)+2);
    // 4.
    char c = p[2][2];
}

同上