定制网站本地企业,小程序定制开发公司,网易云音乐wordpress插件,济南网站建设多少钱定义指针
/*指针的概念:1.为了方便访问内存中的内容#xff0c;给每一个内存单元#xff0c;进行编号#xff0c;那么我们称这个编号为地址#xff0c;也就是指针。2.指针也是一种数据类型#xff0c;指针变量有自己的内存#xff0c;里面存储的是地址#xff0c;也就是…定义指针
/*指针的概念:1.为了方便访问内存中的内容给每一个内存单元进行编号那么我们称这个编号为地址也就是指针。2.指针也是一种数据类型指针变量有自己的内存里面存储的是地址也就是那些编号。四要素1.指针本身的类型 例如float* int* ...2.指针指向的类型 例如float int ...3.指针本身的内存4.指针指向的内存运算符*1.定义指针时通过 * 符号来表示定义的是一个指针并且是指针自身的类型的组成部分2.其他时候表示解析引用取内容通过内存编号读取内存中的内容取(首)地址符作用取出内存的首地址
*/# include stdio.hint main()
{// 定义指针指针:pointerfloat* p_name; // 指针本身的类型:float* 指针指向的类型:floatint * p1;int *p2; // * 符号偏不偏移不影响其功能return 0;
}指针初始化与赋值
/*知识储备// 初识化定义的同时给值int a 0;// 赋值先定义再给值int b;b 0;
*/# include stdio.hint 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:0X0int* 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.hint 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.hint a; // 普通“全局”变量初识值默认为零
// 作用域当前项目
// 生命周期程序开始到结束static int b; // 静态“全局”变量初识值默认为零
// 作用域当前文件
// 生命周期程序开始到结束int main()
{ int c; // 普通局部变量无初始值// 作用域当前语块// 生命周期当前语块static int d; // “静态”局部变量初识值默认为零// 作用域当前语块// 生命周期程序开始到结束return 0;
}# include stdio.hvoid 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 6b 8.8;int* p1 a;double* p2 b;void* p0 NULL; // 当作存放“内存地址”的容器使用p0 p1;p0 p2;...*/# include stdio.hint main()
{ void* p0 NULL;return 0;
}简单开辟内存
/*简单开辟内存1.申请---有两个函数能够实现申请内存的功能A. malloc(参数需要字节的总数);B. calloc(参数每个需要的字节数个数);返回值都是 void* 类型的指针2.使用3.释放free(参数首地址)如果不释放的话会导致“内存泄露”4.置空如果不置空的话会出现“野指针”
*/# include stdio.hint 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.hint 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.hint 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.hint 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.hint 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.hint* 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.hint func(); // 声明int main()
{ // 定义函数指针并进行初始化int(*p)() func; // 即定义了指针p而且 p 等于 funcfunc里面存的是函数的首地址func();p();return 0;
}int func()
{printf(成功执行了 func 函数\n);return 6;
}// 函数指针知识扩展1# include stdio.hint func(); // 声明typedef int funcType(); // 将 int...() 取别名为 funcTypeint main()
{ funcType* p func;p();return 0;
}int func()
{printf(成功执行了 func 函数\n);return 6;
}// 函数指针知识扩展2# include stdio.hint 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.hint 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.hint 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.htypedef 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.htypeof 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.hint 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.htypedef 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.htypedef 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.防止内存泄漏只有堆区是自己申请自己释放其他地方都是系统分配系统回收总结指针能够直接操作内存必须在自己明确用途的情况下使用否则很可能会造成严重后果
*/
