10.郝斌C语言笔记——指针

指针的重要性

    表示一些复杂的数据结构;
    快速的传递数据,减少了内存的耗用;
    使函数返回一个以上的值;
    能直接访问硬件;
    能够方便的处理字符串;
    是理解面向对象语言中引用的基础.

    总结:
        指针是C语言的灵魂.

指针的定义

    地址
        内存单元的编号;
        从零开始的非负数整数;
        范围:
            4G【0 - 4G-1】
    
    指针
        指针就是地址,地址就是指针;
        指针变量就是存放内存单元编号的变量,或者说指针变量就是存放地址的变量;
        指针的本质就是一个操作受限的非负整数;
        指针和指针变量是两个不同的概念;
        但是要注意:
            通常我们叙述时会把指针变量统称为指针,实际它们含义不一样.

指针的分类

    基本类型指针
        指针热身程序
            int * p;//p是变量的名字, int *表示p变量存放的是int类型变量的地址;
                    //int * p; 不表示定义了一个名字叫做*p的变量;
                    //int * p; 应该这样理解: p是变量名, p变量的数据类型是 int * 类型;
                    //所谓int *类型 实际就是存放int变量地址的类型.
            int i = 3;
            int j;
            p = &i;
            /*
                p保存了i的地址,因此p指向i;
                p不是i, i也不是p, 更准确的说: 修改p的值不影响i的值,修改i的值也不会影响p的值;
                如果一个指针变量指向了某个普通变量,则
                    *指针变量 就完全等同于 普通变量
                例子:
                    如果p是个指针变量,并且p存放了普通变量i的地址,
                    则p指向了普通变量i,
                    *p 就完全等同于 i
                    或者说:
                        在所有出现*p的地方都可以替换成i;
                        在所有出现i的地方都可以替换成*p;
                    
                    *p 最准确的解释是:
                        *p 表示的是以p的内容为地址的变量.
            */
            j = *p; //等价于 j = i;
            printf("i = %d, j = %d\n", i, j);
        
        提示:
            int * p; 等价于 int *p; 或 int* p;
            
        附注:
            *的含义:
                乘法;
                定义指针变量;
                    int *p;
                    //定义了一个名字叫p的变量, int *表示p只能存放int变量的地址.
                    //p指针变量只能保存对应类型的变量的地址
                指针运算符;
                    该运算符放在已经定义好的指针变量的前面,
                    如果p是一个已经定义好的指针变量,
                    则 *p表示 以p的内容为地址的变量.
                
            如何通过被调函数修改主调函数普通变量的值:
                实参必须为该普通变量的地址;
                形参必须为指针变量;
                在被调函数中通过
                    *形参名 = ...
                    的方式就可以修改主调函数相关变量的值

    指针和数组
        指针和一维数组
            一维数组名
                一维数组名是个指针常量
                它存放的是一维数组第一个元素的地址

            下标和指针的关系
                如果p是个指针变量,则
                    p[i] 永远等价于 *(p+i)

            确定一个一维数组需要几个参数【如果一个函数要处理一个一维数组,则需要接收数组的那些信息】
                需要两个参数:
                    数组第一个元素的地址
                    数组的长度

            指针变量的运算
                指针变量不能相加 不能相减 也不能相除
                如果两个指针变量指向的是同一块连续空间中的不同存储单元,
                则这两个指针变量才可以相减

            一个指针变量到底占几个字节
                预备知识:
                    sizeof(数据类型)
                    功能:
                        返回值就是该数据类型所占的字节数
                    例子:
                        sizeof(char) = 1 
                        sizeof(int) = 4
                        sizeof(double) = 8

                    sizeof(变量名)
                    功能:
                        返回值是该变量所占的字节数

                    假设p指向char类型变量(1个字节)
                    假设q指向int类型变量(4个字节)
                    假设r指向double类型变量(8个字节)
                    请问:p q r本身所占的字节数是否一样?
                    答案:
                        p q r本身所占的字节数都一样
                    总结:
                        一个指针变量,无论它指向的变量占几个字节,
                        该变量本身只占四个字节
                        32位(内存位数) / 8位(1个字节) = 4个字节

                        一个变量的地址是用该变量首字节的地址来表示
        
        指针和二维数组
    
    指针和函数

    指针和结构体

    多级指针
        示例:
            int i = 10;
            int * p = &i;//p只能存放int类型变量的地址
            int ** q = &p;//q是int ** 类型,所谓int ** 类型就是指q只能存放int * 类型变量的地址
            int *** r = &q;//r是int *** 类型,所谓int *** 类型就是指r只能存放int ** 类型变量的地址

            //r = &p;//错误,因为r是int *** 类型,r只能存放int **类型变量的地址
            printf("i = %d\n", ***r);//输出结果是10
            //只有 ***r 才表示是i, *r或 **r 或 ****r代表的都不是i

专题

    动态内存分配
        传统数组的缺点:
            数组长度必须事先制定,且只能是常整数,不能是变量
            例子:
                int a[5];//OK
                int len = 5;
                int a[len];//错误
            
            传统形式定义的数组,该数组的内存程序员无法手动释放.
            在一个函数运行期间,系统为该函数中数组所分配的空间
            会一直存在,直到该函数运行完毕时,数组的空间才会被
            系统释放.

            数组的长度一旦定义,其长度就不能在更改
            数组的长度不能在函数运行的过程中动态的扩充或缩小
            
            A函数定义的数组,在A函数运行期间可以被其他函数使用,
            但A函数运行完毕后,A函数中的数组将无法在被其他
            函数使用.
            传统方式定义的数组不能跨函数使用.

        为什么需要动态分配内存
            动态数组很好的解决了传统数组的这4个缺陷
            传统数组也叫静态数组

        动态内存分配举例_动态数组的构造
            假设动态构造一个int型一维数组
                int * p = (int *)malloc(int len);
                    本语句分配了两个内存,一块内存是动态分配的,
                    总共len个字节,另一块是静态分配的,
                    并且这个静态内存是p变量本身所占的内容,总共4个字节

                    malloc只有一个int型的形参,表示要求系统分配的字节数
                    
                    malloc函数的功能是请求系统len个字节的内存空间,如果请求分配成功,
                    则返回第一个字节的地址,如果分配不成功,则返回NULL
                    malloc函数能且只能返回第一个字节的地址,所以我们需要把这个无任何实
                    际意义的第一个字节的地址(俗称干地址)转化为一个有实际意义的地址,
                    因此
                    malloc前面必须加(数据类型 *),表示把这个实际意义的第一个字节的地址
                    转化为相应类型的地址,如:
                        int * p = (int *)malloc(50);
                            表示将系统分配好的50个字节的第一个字节的地址转化为int *型的
                            地址,更准确的说是把第一个字节的地址转化为四个字节的地址,这
                            样p就指向了第一个的四个字节, p+1就指向了第2个的四个字节,
                            p+i就指向了第i+1 个的4个字节,p[0]就是第一个元素, p[i]就是第
                            i+1个元素
                        double * p = (double *)malloc(80);
                            表示将系统分配好的80个字节的第一个字节的地址转化为double *型
                            的地址,更准确的说是把第一个字节的地址转化为8个字节的地址,这
                            样p就指向了第一个的8个字节, p+1 就指向了第2个的8个字节,
                            p+i就指向了第i+1个的8个字节。p[0]就是第一个元素, p[i]就是第
                            i+1个元素
                
                free(p);
                    表示把p所指向的内存给释放掉 p本身的内存是静态的,
                    不能由程序员手动释放,p本身的内存只能在p变量所在的
                    函数运行终止时由系统自动释放
        
        静态内存和动态内存的比较
            静态内存是由系统自动分配,由系统自动释放
            静态内存是在栈分配的

            动态内存是有程序员手动分配,手动释放
            动态内存是在堆分配的
        
        跨函数使用内存的问题
            静态内存不可以跨函数使用
                所谓静态内存不可以跨函数使用更准确的说法是:
                    静态内存在函数执行期间可以被其他函数使用

如有不对或者疏漏的地方，请多多指出。谢谢(⁄ ⁄•⁄ω⁄•⁄ ⁄)