定义指针

/*指针的概念:1.为了方便访问内存中的内容，给每一个内存单元，进行编号，那么我们称这个编号为地址，也就是指针。2.指针也是一种数据类型，指针变量有自己的内存，里面存储的是地址，也就是那些编号。四要素1.指针本身的类型    例如：float*    int*    ...2.指针指向的类型    例如：float        int        ...3.指针本身的内存4.指针指向的内存运算符*：1.定义指针时，通过 * 符号，来表示定义的是一个指针，并且是指针自身的类型的组成部分2.其他时候，表示解析引用（取内容：通过内存编号，读取内存中的内容）&：取(首)地址符，作用：取出（内存的）首地址
*/# include <stdio.h>int main()
{// 定义指针（指针:pointer）float* p_name;    // 指针本身的类型:float*    指针指向的类型:floatint * p1;int *p2;        // * 符号偏不偏移不影响其功能return 0;
}

指针初始化与赋值

/*知识储备：// 初识化：定义的同时，给值int a = 0;// 赋值：先定义，再给值int b;b = 0;
*/# include <stdio.h>int main()
{    // 初始化int num = 6;int val = 8;// 初始化int* p1 = &num;    // 对于指针变量p1，如果进行给值，必须给地址（内存编号）// 赋值int* p2;p2 = &val;// 自行体会int* p3 = p1;// 直接存入地址（不推荐使用，因为你不知道自己随便写的地址里面是什么！！）int* p4 = (int*)123456;    // 将 整型123456 强转为 int*类型 的“地址”int* p5 = (int*)0XAB25;    // 计算机中的内存地址通常用16进制数表示// 直接使用地址：置空（即："使用0地址，NULL:0X0"）int* p6 = NULL;    // 等价于 int* p6 = (int*)0X0;// 目的：为了给暂无指向的指针，提供指向，保证安全，将内存中的0地址特殊化// 数组名就是数组的首地址int arr[3] = { 1, 2, 3 };// 数组类型：int [3]// 元素类型：int// arr 类型：int*int* p7 = arr;return 0;
}

探究内存

/*1.变量在内存中所占的字节数所有的指针变量，不论类型，在内存中所占的字节数都是一样的，都是4个字节（或者8个字节）（8个字节是因为时代的发展，部分好的计算机性能得到提升，一般都是4个字节）2.指针本身的内存，以及指针指向的内存指针本身的内存：4个字节（指针变量只需要存储，所指向的变量的首地址）指针指向的内存：看你所指向的类型，视情况而定
*/# include <stdio.h>int main()
{    double num = 12.0;double* p1 = &num;printf("%f \n", num);printf("%f \n", *p1);    // 利用指针，取得 num 的值return 0;
}

指针的偏移

• 大端模式与小端模式：前往学习

内存区域划分-基础

/*
内存区域的划分
四个：常量区，栈区，堆区，静态全局区
五个：常量区，栈区，堆区，静态全局区，代码区1.代码区：存代码
2.常量区：存常量
3.静态全局区：静态(static)变量，全局变量
4.栈区：普通局部变量
5.堆区：由程序员手动申请，手动释放
*/# include <stdio.h>int a;                // 普通“全局”变量（初识值默认为零）
// 作用域：当前项目
// 生命周期：程序开始到结束static int b;        // 静态“全局”变量（初识值默认为零）
// 作用域：当前文件
// 生命周期：程序开始到结束int main()
{    int c;            // 普通局部变量（无初始值）// 作用域：当前语块// 生命周期：当前语块static int d;    // “静态”局部变量（初识值默认为零）// 作用域：当前语块// 生命周期：程序开始到结束return 0;
}

# include <stdio.h>void func()
{static int num;        // 只会定义一次printf("%d \n", num);num++;printf("%d \n", num);}int main()
{    func();func();func();return 0;
} /*运行结果：011223请按任意键继续. . .
*/

空类型指针

/*void* 指针1.不能自增自减2.不能偏移3.不能读取内容但是！可以接收任何类型的指针而不需要强转类型可以利用这个特点，将 void* 指针当作通用的存放地址的“容器”e.g.int a = 6，b = 8.8;int* p1 = &a;double* p2 = &b;void* p0 = NULL;    // 当作存放“内存地址”的容器使用p0 = p1;p0 = p2;...*/# include <stdio.h>int main()
{    void* p0 = NULL;return 0;
}

简单开辟内存

/*简单开辟内存1.申请---有两个函数能够实现申请内存的功能：A. malloc(参数：需要字节的总数);B. calloc(参数：每个需要的字节数，个数);返回值都是 void* 类型的指针2.使用3.释放free(参数：首地址)如果不释放的话，会导致“内存泄露”4.置空如果不置空的话，会出现“野指针”
*/# include <stdio.h>int main()
{    /* malloc */double* p = (double*)malloc(sizeof(double));    // 申请一个double类型大小的内存（8字节）*p = 3.14;    // 使用printf("%lf \n", *p);free(p);    // 通过 p 里面存储的首地址，找到相对应的内存，从这里开始释放，一直释放到，申请内存的时候，做了标记的地方p = NULL;    // 通过置空，让指针不再指向已经被释放掉的内存/* calloc */float* p1 = (float*)calloc(sizeof(float),1);*p1 = 3.14f;printf("%f \n", *p1);free(p1);p1 = NULL;printf("进阶运用 \n");// 进阶运用p = (double*)malloc(sizeof(double)*10);    // 申请10个 double 类型大小的连续的内存（补充：因为上面将p定为 double* 而且置空过了，所以可再度利用）for (int i = 0; i < 10; i++ ){    *(p + i) = 10 + i;    // 给值printf("%lf \n", *(p + i));    // 展示值}free(p);p = NULL;/*对于上面 for 循环部分的补充：p：里面存的是：申请的内存的首地址在一次申请中，申请的内存是连续的*(p + i) <===> p[i]        // 注意！它不是数组！*/return 0;
}

# include <stdio.h>int main()
{    // 指针布局int row = 3;int** pp = (int**)calloc(sizeof(int*), row);int len = 4;for (size_t i = 0; i < row; i++)    // size_t是什么？点我跳转学习{pp[i] = (int*)calloc(sizeof(int), len);}// 内容展示for (size_t i = 0; i < row; i++){for (size_t j = 0; j < len; j++){    pp[i][j] = i * 10 + j;    // 给值printf("%-5d", pp[i][j]);    // 展示值，注意！这里不是二维数组！(看不懂请回顾上页内容)}printf("\n");}// 释放内存for (size_t i = 0; i < row; i++){free(pp[i]);pp[i] = NULL;}free(pp);pp = NULL;return 0;
}

自动扩容

# include <stdio.h>int main()
{    int len = 5;    // 默认长度int* p = (int*)calloc(sizeof(int), len);int num = 1;for (size_t i = 0; num != 0; i++)    // 用户不输入0结束，就一直获取数据并复制到开辟的内存中{scanf("%d", &num);p[i] = num;        // 数据复制到开辟的内存中}for (size_t i = 0; p[i] != 0; i++){printf("%-5d", p[i]);    // 展示数据}free(p);p = NULL;return 0;
}

/*扩容的本质是：将小内存中的所有内容拷贝到大内存中，然后，再继续对大内存进行别的操作
*/# include <stdio.h>int main()
{    // 长度int len = 5;// 首次申请内存int* p = (int*)calloc(sizeof(int), len);int* temp = p;    // 成为p的分身，以防万一// 重复输入数据（并复制到内存中）int num = 1;int i = 0;while (scanf("%d", &num), num != 0){if (i < len)    // 没满的情况下{temp[i++] = num;    // 存完一次，记录一下}else   // 满了的情况下{len += 5;p = (int*)calloc(sizeof(int), len);        // 重新申请更大的内存for (int j = 0; j < i; j++){p[j] = temp[j];}free(temp);temp = NULL;temp = p;    // 继续成为当前p的分身temp[i++] = num;}}// 输出数据printf("--------------------\n");for (int j = 0; j != i; j++){printf("%d \n", temp[j]);}free(p);p = NULL;temp = NULL;return 0;
}

内存区域划分-进阶

/*内存区域的划分1.代码区存储代码2.常量区存储常量3.全局区(静态全局区)存储: 1.静态变量    2.全局变量# include <stdio.h>int c;            // 普通全局变量static int d;    // 静态全局变量int main(){int a;            // 普通局部变量static int b;    // 静态局部变量int c;    // 注意这个c不是上面的c，它们只是名字看起来一样而已a = 10;        // 普通局部变量没有默认初始值，所以需要自己赋值printf("a = %d \n", a);printf("b = %d \n", b);printf("c = %d \n", c);printf("d = %d \n", d);// 通过以上 printf，可以总结规律：静态全局区，默认的初始值为0// 作用域和生命周期作用域            生命周期普通全局变量        当前项目        程序开始到程序结束静态全局变量        当前文件        程序开始到程序结束普通局部变量        当前语块        当前语块静态局部变量        当前语块        程序开始到程序结束return 0;}4.栈区存储：普通局部变量从定义时系统自动分配内存，离开当前语块系统就会自动回收内存 5.堆区由程序员手动申请和释放
*/

指针与函数

/*1.指针函数返回值类型是指针的函数2.函数指针指向函数的指针
*/

// 1.指针函数// 下面的代码是一个错误的例子，你能发现它的错误吗？
# include <stdio.h>int* test();    // 声明int main()
{    int* temp = test();printf("%d \n", *temp);return 0;
} int* test()
{int num = 10;int* p = &num;return p;    // 返回了栈区变量的首地址（非常严重的问题！详情见下）
}/*下面的内容是在栈区，当运行完毕，系统会回收其内存资源：int* test(){int num = 10;int* p = &num;return p;}当函数返回栈区变量 num 的内存地址之后，函数运行完毕，系统回收 num 内存，供以后"某某东西"使用所以，返回的地址不但没有作用，还会导致以后非法访问内存的问题出现*/

// 2.函数指针/*函数指针的定义返回类型说明符 (*函数指针变量名)(参数列表);
*/# include <stdio.h>int func();    // 声明int main()
{    // 定义函数指针，并进行初始化int(*p)() = func;    // 即：定义了指针p，而且 p 等于 func（func里面存的是函数的首地址）func();p();return 0;
}int func()
{printf("成功执行了 func 函数！\n");return 6;
}

// 函数指针，知识扩展1# include <stdio.h>int func();    // 声明typedef int funcType();    // 将 int...() 取别名为 funcTypeint main()
{    funcType* p = func;p();return 0;
}int func()
{printf("成功执行了 func 函数！\n");return 6;
}

// 函数指针，知识扩展2# include <stdio.h>int func(int a, int b);    // 声明typedef int(*pfunc)(int a, int b);int main()
{    pfunc p = func;        // 这样也能定义函数指针int res = p(1,2);printf("%d \n", res);return 0;
}int func(int a, int b)
{printf("成功执行了 func 函数！\n");return a + b;
}

指针与数组

/*1.指针数组......2.数组指针......
*/

// 1.指针数组/*# include <stdio.h>int main()
{    // 定义并初始化"数组"int arr1[3] = { 1, 2, 3 };    // 数组 arr1[3] -> 里面存的都是 int 类型// 定义并初始化"指针数组"int* arr2[3] = { 地址1，地址2，地址三 };    // 数组 arr2[3] -> 里面存的都是 int* 类型arr2[2] = 新地址;return 0;
} */

// 2.数组指针/*定义"数组"指针:所指向的数组里面存的数据类型 (*数组指针名称)[所指向的数组的长度];
*/# include <stdio.h>int main()
{    int arr[3] = { 1, 2, 3 };    // 建立一个数组。
//    arr 里面存的是数组内存的首地址，而 [] 表示内存里面存的那一堆东西是数组，3 表示数组长度，int 表示数组里面存的数据是 int 类型int(*p)[3];    // 长度为 3 的数组指针p = arr;printf("%d \n", p[1]);return 0;
}

// 数组指针，知识扩展# include <stdio.h>typedef int(*pType)[3];    // 定义类型：int(*pType)[3]，取别名为：pTypeint main()
{    int arr[3] = { 1, 2, 3 };pType p;    // 变量 p 的类型为 pType，而属于这种类型的变量 p 必然满足 int(*pType)[3] 模板格式p = arr;    // arr里面储存的“数组的内存首地址”复制给变量 pprintf("%d \n", (*p)[0]);    // 注意！不要写成 p[0]，虽然 p 获得了 arr 里面存的首地址，但是 *p 才是代表数组整体return 0;
} /*同理：# include <stdio.h>typeof int pArr[3];int main(){int arr[3] = { 1, 2, 3 };pArr p;p = arr;}
*/

使用const修饰指针

/*const：常量，被它修饰的变量会具有常量的属性，使用 const 修饰指针包含三种情况1.常量指针(指向常量的指针)指向常量的指针 type const *p; 或者 const type *p;可以改变指向，但是不能用 *p 修改指向变量的值2.指针常量它是常量，本身不能改变，也就是不能改变指向因为指向不能改，所以必须初始化但是可以通过取内容修改指向的内存中的内容3.常量指针常量（"常量指针"常量即：指针常量）指针本身是一个常量，指向的也是常量const int * const p = &a;不能改变指向，也不能改变指向的内存的内容
*/# include <stdio.h>int main()
{const int num = 0;    // 变量 num 使用 const 修饰了就不能被修改了// 1.常量指针int a = 0, b = 9;const int * p = &a;        // const -> intp = &b;    // 可以改变指向// 2.指针常量int c = 6;int* const p1 = &c;        // const -> p1*p1 = 10;    // 可以修改内容// 3.常量指针常量int d = 8;const int* const p = &d;    // const -> int 和 preturn 0;}

指针和结构体

/*指针与结构体：指针与结构体结合起来使用包含两种情况：一.指针成员结构体变量的成员中存在指针二.结构体指针指向结构体变量的指针
*/

// 指针成员# include <stdio.h>typedef struct
{int n;int m;int* p;    // 定义指针}MyStruct;int main()
{MyStruct mystr;mystr.n = 0;mystr.m = 0;mystr.p = NULL;    // 地址置空return 0;}

// 结构体指针# include <stdio.h>typedef struct
{int n;int m;}MyStruct;int main()
{MyStruct mystr;mystr.n = 0;mystr.m = 0;MyStruct* p = NULL;    // 定义一个指针 p ,它的类型是 MyStruct*，即该指针指向的是有 MyStruct 类型的变量(首地址)p = &mystr;    // mystr 便符合条件，可以将首地址 &mystr 赋值给 p// 注意！通过指针访问“结构体中的元素”的时候，用 -> 符号，而不是用 . 符号p->n = 9;p->m = 8;return 0;}

使用指针的注意事项

/*注意事项1.避免野指针推荐：每次定义指针都进行初始化(有指向就给指向，没指向就置空 )2.注意类型匹配3.防止内存泄漏只有堆区是自己申请，自己释放，其他地方都是系统分配，系统回收总结：指针能够直接操作内存，必须在自己明确用途的情况下使用，否则很可能会造成严重后果！
*/