【C语言笔记】<十五>指针

指针的基本概念

#include <stdio.h>

// 基本数据类型作为函数的参数是值传递, 在函数中修改形参的值不会影响到外面实参的值
void change(int value) // int value = 10;
{
    value = 55;
    printf("哥被执行了\n");
}

// 数组作为函数的参数是地址传递, 如果是地址传递在函数中修改形参的值会影响到外面实参的值
void change2(int values[])
{
    values[1] = 88;
    printf("哥被执行了\n");
}


// 指针就是专门用于保存地址的
void change3(int *p) // 用什么接收地址?   指针 = 0ffc13  int *p = &num;
{
    *p = 55;
    printf("哥被执行了\n");
}

int main(int argc, const char * argv[]) {
    // 需求: 定义一个函数, 在函数中修改传入的实参的值
    /*
    int num = 10;
    printf("修改前:num = %i\n", num);
    change(num);
    printf("修改后:num = %i\n", num);
     */
    
    /*
    int nums[] = {1, 3};
    printf("修改前:nums[1] = %i\n", nums[1]);
    // nums == &nums == &nums[0]
    change2(nums);
    printf("修改前:nums[1] = %i\n", nums[1]);
    */
    

    int num = 10;
    // *p == num
    printf("修改前:num = %i\n", num);
    change3(&num);
    printf("修改后:num = %i\n", num);
    
    /*
     如何定义指针变量
     普通变量:
     数据类型 变量名称;
     
     指针变量:
     数据类型 * 变量名称;
     
     数据类型 : 说明将来指针变量能够保存什么类型的变量的地址
               注意: 指针变量是什么类型, 那么将来就只能保存什么类型变量的地址, 
               例如: 指针变量是int类型, 那么将来就只能保存int类型变量的地址
     * : 没有任何特殊含义, 仅仅是为了标示这是一个指针变量
     变量名称 : 用于区分不同的变量
     
     */
    /*
    int num; // 普通变量
    num = 10;
    
    int *p; // 指针 , 在64位编译器下占用8个字节
    // 千万注意: 指针变量只能存储地址
    p = &num; // 将num的地址存储到p这个指针中
    
    // p == &num
    printf("num = %p\n", &num);
    printf("p = %p\n", p);
    
    // 指针变量前的*号代表访问指针变量指向的那一块存储空间
    // *p == num
    *p = 55;
    printf("num = %i\n", *p);
    */
    
    return 0;
}

指针的注意点

#include <stdio.h>

int main(int argc, const char * argv[]) {
    // 1.指针只能保存地址
    /*
    int *p = 200;
    printf("%i\n", *p);
     */
    
    /*************************华丽的分割线*******************************/
    
    // 2.同一个变量可以有多个指针指向它
    /*
    int num = 10;
    int *p = &num;
    // *p == num
//    num = 55;
    *p = 55;
    
    int *p1 = p;
    *p1 = 100;
    
    int *p2 = &num;
    
    printf("%i\n", *p);
     */
    
    /*************************华丽的分割线*******************************/
    
    // 3.指针的指向可以修改
    /*
    int a = 10;
    int b = 5;
    
    int *p = &a;
    *p = 88;
    
    p = &b;
    
    *p = 44;
    
    printf("%i\n", a);
    printf("%i\n", b);
    */
    
    /*************************华丽的分割线*******************************/
    
    // 4.不要访问野指针
    /*
    // 没有赋值的指针, 我们称之为野指针
//    int *p;
    int *p = NULL; // 0
    printf("%i\n", *p);
     */
    
    /*************************华丽的分割线*******************************/
    
    // 5.指针类型是什么类型, 就只能指向什么类型的数据
    /*
    int num = 10;
    char charValue = 'l';
    double doubleValue = 9.9;
    
//    int *p = &num;
//    int *p = &charValue;
//    int *p = &doubleValue;
    
    double *p = &doubleValue;
    printf("%lf\n", *p);
     */
    
    return 0;
}

多级指针

int main(int argc, const char * argv[]) {
    
    /*
    char charValue = 'l';
    // 1.拷贝需要指向的变量的数据类型和变量名称
    // 2.在数据类型和变量名称之间加上一颗星
    // 3.修改变量名称
    char *charValueP;
    charValueP = &charValue;
    
    // 1.拷贝需要指向的变量的数据类型和变量名称
    // 2.在数据类型和变量名称之间加上一颗星
    // 3.修改变量名称
    char **charValuePP; // 不管有几颗*只要是指针变量就占用8个字节
//    printf("size = %lu\n", sizeof(charValuePP));
    charValuePP = &charValueP;
    
//    charValue = 'j';
    // *charValueP == charValue
//    *charValueP = 'j';
    
    // &charValue == charValueP
    printf("&charValue = %p\n", &charValue);
    printf("charValueP = %p\n", charValueP);
    // &charValueP == charValuePP
    printf("&charValueP = %p\n", &charValueP);
    printf("charValuePP = %p\n", charValuePP);
    
    // *charValuePP == 0ffc14 ==  charValueP
    // *pp == p
    
    // **charValuePP == *(*charValuePP) == *charValueP == 0ffc14 == l
    **charValuePP = 'n';
    
    printf("%c\n", **charValuePP);
    */
    
    /*************************华丽的分割线*******************************/
    
    char c = 'a';
    char *cp;
    cp = &c;
    char **cpp;
    cpp = &cp;
    char ***cppp;
    cppp = &cpp;
    printf("cppp = %c\n", ***cppp);
    
    /*
     
     *cp == c;
     *cpp ==  cp;
     **cpp == *(*cpp) == *cp == c
     多级指针的操作, 最简单的方式, 就是通过几颗星来存储, 就通过几颗星来访问
     还有一种方式就是画图, 看图片中有几个箭头, 有几个简单就用几颗星来访问
     */
    printf("c = %c\n", c);
    printf("*cp = %c\n", *cp);
    printf("&c = %p\n", &c);
    printf("cp = %p\n", cp);
    printf("*cpp = %p\n", *cpp);
    printf("**cpp = %c\n", **cpp);
    
    return 0;
}

指针为什么分类型

int main(int argc, const char * argv[]) {
    /*
    char *cp;
    int *ip;
    double *dp;
    double **dpp;
    // mac系统中的指针无论是什么类型, 几级真正都占用8个字节
    // 由于Mac是64位了,  32  = 4 * 8;  64 = 8 * 8;
    printf("cp = %lu, ip = %lu, dp = %lu, dpp = %lu\n", sizeof(cp), sizeof(ip), sizeof(dp), sizeof(dpp));
     */
    // 指针为什么要分类型?
    // 因为当我们利用指针去取值的时候, 系统就会自动根据指针的类型来确定应该取对少个字节中的值
    int  intValue = 1230; //
    char charValue = '1';
    /*
     00110001
     11001110
     00000100
     00000000
     
     00000000 00000100 11001110 00110001
     */
    /*
    int *charValueP;
    charValueP = &charValue;
    
    printf("%i\n", *charValueP);
    printf("%i\n", 0b00000000000001001100111000110001);
     */
    
    /*
     11001110
     */
    char *p = &intValue;
    printf("%i\n", *p);
    
    return 0;
}