C语言指针知识点总结
C语言指针的长度和类型详解
C语言指针的长度和类型详解C语言指针的长度和类型详解指针是C语言的精髓，以下是店铺搜索整理的关于C语言指针的长度和类型详解，对于初学者深入理解C语言程序设计有很好的参考价值，有需要的朋友可以参考一下!想了解更多相关信息请持续关注我们店铺!一般来说，如果考虑应用程序的兼容性和可移植性，指针的长度就是一个问题，在大部分现代平台上，数据指针的长度通常是一样的，与指针类型无关，尽管C标准没有规定所有类型指针的长度相同，但是通常实际情况就是这样。
但是函数指针长度可能与数据指针的长度不同。
指针的长度取决于使用的机器和编译器，例如：在现代windows 上，指针是32位或是64位长测试代码如下：#include<stdio.h>#include<math.h>#include<stdlib.h>#include<stddef.h>struct p{int n;float f;};int main(){struct p *sptr;printf("sizeof *char: %d ", sizeof(char*));printf("sizeof *int: %d ", sizeof(int*));printf("sizeof *float: %d ", sizeof(float*));printf("sizeof *double: %d ", sizeof(double*));printf("sizeof *struct: %d ", sizeof(sptr));return 0;}运行结果如下图所示：指针相关的预定义类型：① size_t：用于安全地表示长度② ptrdiff_t：用于处理指针算术运算③ intptr_t：用于存储指针地址④ uintptr_t：用于存储指针地址分述如下：一、size_t类型size_t 类型是标准C库中定义的，应为unsigned int，在64位系统中为long unsigned int。
C语言程序设计知识点—第8章 指针结构体与预处理命令
指针使用示例 2 void main() { int num1 = 50, num2 = 100; int *ptr1, *ptr2; ptr1 = &num1; printf(" num1 的值是： %d", *ptr1); printf("\n num1 的地址是： %x \n", ptr1); ptr2 = &num2; printf("\n num2 的值是： %d", *ptr2); printf("\n num2 的地址是： %x \n", ptr2); *ptr2 = *ptr1; printf("\n 重新赋值后 num2 的值是： %d", *ptr2); printf("\n 重新赋值后 num2 的地址是： %x\n", ptr2); }
C 语言程序设计知识点
主讲教师：杨剑
第 8 章：指针、结构体与预处理命令
1. 本章目标
理解指针的概念 定义指针变量 掌握对指针的操作 理解指针和数组的关系 理解结构体的概念和定义 理解预处理指令
2. 内存地址
内存是一个连续编址的空间，每一个存储单元都有一个固定的编号，称为内存地址。 内存地址通常用 16 进制数表示。
c语言中指针用法
1) 运算符 ：*
该运算符作用在指针变量上，表示访问指针
变量所指向的数据对象编。辑课件
22
2）作用：
实现对指针所指向的数据对象的间接访问， 包括引用和赋值等基本运算。
例6-6 下面的程序段包含着对指针的间接访问。
int a,b=2,c,*p; …… p=&b; scanf("%d",&a); c=a+*p;
1．指针的赋值
操作指针之前必须赋予确定的值，可以在 定义指针的同时赋予初值，也可以用赋值表达 式对指针变量赋值。
（1）赋空值（NULL）； （2）赋予某个变量的地址。 （3）将一个指针变量的值赋予另一指针变量。
例如：int grade,*p； 编辑课件
16
p=&grade;
2．指针的加减运算
1）运算符：+、-、++、-- 。
--：原地址减去一个地址单位（基类型的实际字 节数）；
例如： int *iptr; …… iptr++；// iptr=iptr+1，向下移动两个字节 iptr--；// iptr=iptr-1，向上移动两个字节
下图给出指针的移动示编意辑课：件
19
3. 取地址运算
1) 运算符：& 2) 作用：获取数据对象的内存地址，如果是结 构数据对象则获取其内存首地址。
重点：
➢ 指针的概念 ➢ 指针运算； ➢ 内存操作函数和动态存储分配。
课堂时数：6—7学时 上机时数：2—3学时 课外上机时数：2—3学时
编辑课件
2
6.1 指针的概念
1. 什么叫指针
一个数据对象的内存地址称为该数据对象 的指针 。
C语言指针知识点
C语言指针知识点C语言指针知识点引导语：在信息工程中，指针是一个用来指示一个内存地址的计算机语言的变量或中央处理器(CPU)中的寄存器(Register)。
以下是店铺分享给大家的C语言指针知识点，欢迎阅读!【考点1】指针变量指针变量是用来存储地址的，而一般变量是存储数值的。
指针变量可指向任意一种数据类型，但不管它指向的数据占用多少字节，一个指针变量占用四个字节。
【考点2】指针变量的定义格式为：类型名*指针变量名。
二维指针int **p;可以理解为基类型为(int *)类型。
【考点3】指针变量的初始化指针变量在使用前必须要初始化，把一个具体的地址赋给它，否则引用时会有副作用，如果不指向任何数据就赋“空值”NULL。
指针变量两种初始化方法一：int a=2，*p=&a;(定义的同时初始化)方法二：int a=2，*p; (定义之后初始化)p=&a;【考点4】指针变量的引用&是取地址符，*是间接访问运算符，它们是互逆的两个运算符。
在指针变量名前加间接访问运算符就等价它所指向的量。
【考点5】指针的`运算int *p 中 *p 和p 的差别：*p 可以当做变量来用;*的作用是取后面地址p 里面的数值p 是当作地址来使用。
*p++ 和(*p)++的之间的差别：改错题目中很重要*p++是地址会变化。
(*p)++ 是数值会要变化。
三名主义：(考试的重点)数组名：表示第一个元素的地址。
数组名不可以自加，他是地址常量名。
(考了很多次)函数名：表示该函数的入口地址。
字符串常量名：表示第一个字符的地址。
指针变量是存放地址的。
并且指向哪个就等价哪个，所有出现*p 的地方都可以用它等价的代替指向的变量。
例如：int a=2，*p=&a;*p=*p+2;(由于*p 指向变量a,所以指向哪个就等价哪个，这里*p 等价于a，可以相当于是a=a+2)。
C语言指针知识点总结
指针★指针的重要性表示一些复杂的数据结构快速传递数据使函数返回一个以上的值能直接访问硬件能方便处理字符串是理解面向对象语言中引用的基础总结：指针是C 语言的灵魂★指针的定义 ☆地址内存单元的编号 从零开始的非负整数 范围：4G ☆指针1.指针就是地址，地址就是指针2.指针变量是存放地址的变量3.指针和指针变量是两个不同的概念4.叙述时通常把指针变量简称为指针，实际它们含义不一样5.指针的本质就是一个操作受限的非负整数 ★指针的分类☆基本类型指针（重要） #include<stdio.h> int main(void)Int f(int i,int j){return 100;// return 88;error }Int main (void){Int a=3,b=5;# include <stdio.h> Void g(int*p,int*q){*p=1;*q=2; } Int main(void) {Int a=3,b=5;{int *p; //p是变量的名字，int*表示p变量存放的是int类型变量的地址Int*p;不表示定义了一个名字叫做*p的变量Int*p;应该理解为：p是变量名，p变量的数据类型是int*类型所谓int*类型，实际就是存放int变量地址的类型int i=3;char ch=’A’p=&i; //OK1.p保存了i的地址，因此p指向i2.p不是i，i也不是p，修改p的值不影响i的值，修改i的值也不影响p的值3.如果一个指针变量指向了某个普通变量，则*指针变量完全等同于普通变量例：若p指向i，则*p=i (*p和i 可互相替换)p=&ch;//error//p=i; //error,因为类型不一致，p只能存放int类型变量的地址，不能存放int类型变量//P=55;//error,原因同上return 0；}△附注：?*的含义：1.乘法2.定义指针变量Int*p; //定义了一个名字叫做p的变量，int*表示p只能存放int变量的地址3.指针运算符该运算符放在已经定义好的指针变量的前面如果p是一个已经定义好的指针变量则*p 表示以p 的内容为地址的变量 ?如何通过被调函数修改主调函数普通变量的值 1.实参必须为该普通变量的地址 &... 2.形参必须为指针变量 *...3.在被调函数中通过 *形参名=...... 的方式就可以修改主调函数相关变量的值 例子： 经典指针程序：互换数值形参和实参是不同的变量，修改形参不会改变实参 ?指针常见错误 #include<stdio.h> Int main(void) { Int i=5; Int*p; Int*q; P=&i;//*q=p;//error 语法编译会出错 //*q=*p;//errorP=q;//q 是垃圾值，q 赋给p ，p 也是垃圾值 printf(“%d\n ”,*q); //13行/*q 的空间是属于本程序的，所以本程序可以读写q 的内容，但是如果q 内部是垃圾值，则本程序不能读写*q 的内容因为此时*q 所代表的内存单元的控制限权并没有分配给本程序 所以本程序运行到13行时就会立即出错*/ return 0;#include<stdio.h>void huhuan （int a, int b ） { int t; t=a; a=b; b=t; return; }int main(void) { int a=3; int b=5;huhuan(a,b);#include<stdio.h> void huhuan2（int *p, int *q ） {int *t;//如果要互换p 和q 的值， 则t 必须是int*，不能是int t=p; p=q; q=t; return;}int main(void){int a=3;int b=5; #include<stdio.h>void huhuan3（int *p, int*q ） //形参的名字是p 和q ，接收实参数据的是p 和q ，而不是*p 和*q{int t;//如果要互换*p 和*q 的值， 则t 必须是int ，不能是int* t=*p;//p 是int*，*p 是int *p=*q; *q=t; return; }int main(void) {int a=3;int b=5;}☆指针和数组△指针和一维数组 ?一维数组名一维数组名是个指针常量它存放的是一维数组第一个元素的地址 ?下标和指针的关系如果p 是个指针变量，则p[i]永远等价于*(p+i) ?确定一个一维数组需要几个参数（如果一个函数要处理一个一维数组，则需要接收该数组的哪些信息） 需要两个参数：数组第一个元素的地址 数组的长度?指针变量的运算 指针变量不能相加，不能相乘，不能相除 可以相减（仅当两个指针变量指向的是同一块连续空间中的不同存储空间） ?一个指针变量到底占几个字节 预备知识： sizeof （数据类型）功能：返回值就是该数据类型所占的字节数例子：sizeof （int ）=4 sizeof （char ）=1 sizeof （double ）=8 # include<stdio.h>//f 函数可以输出任何一个一维数组的内容 void f(int * pArr, int len) { int i ； for(i=0,i<len,++i) printf( “%d ”,*(pArr+i) ) //*(pArr+i)等价于pArr[i] b[i] *(b+i) int main(void){ int a[5]={1,2,3,4,5}; int b[6]={-1,-2,-3,4,5,-6};int c[100]={1,99,22,33}; f(a,5);//a 是int*f(b,6); 1 2 3 4 5 -1 -2 -3 4 5 -61 99 22 33 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 # include<stdio.h>void f(int * pArr,int len) { pArr[3]=88; //10行} int main(void) { int a[6]={1,2,3,4,5,6} printf(“%d\n ”,a[3]); //17行 f(a,6); printf(“%d\n ”,a[3]); //19行 若写为&a[3]则输出结果为a[3]的地址 #include<stdio.h> Int main(void){ int i=5;Int j=10; Int*p=&i; #include<stdio.h> Int main(void) { int i=5; Int j=10; Int*p=&i; Int*q=&j; Int a[5]; p=&a[1];#include<stdio.h>Void f(int*pArr,int len){ pArr[2]=10; //pArr[2]==*( pArr+2)==*(a+2)==a[2]}Int main(void) { int a[6]={1,2,3,4,5,6} printf(“%d\n ”,a[2]);f(a,5);printf(“%d\n ”,a[2]); //a=&a[2];//error 因为a 是常量# include<stdio.h> Void OutArr(int*pArr,int len) {Int i; For(i=0;i<len;++i)Printf(“%d\n ”,pArr[i]);}Int main(void) { OutArr(a,5);Return 0; }sizeof （变量名）功能：返回值是该变量所占的字节数 假设p 指向char 类型变量（1个字节） 假设q 指向int 类型变量（4个字节） 假设 r 指向double 类型变量（8个字节）△指针和二维数组☆指针和函数 ☆指针和结构体 ☆多级指针 专题：动态内存分配（重难点）传统数组的缺点：1.数组长度必须事先制定，且只能是常整数，不能是变量。
C指针详解(经典,非常详细)
总结课：让你不再害怕指针指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。
0前言:复杂类型说明要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,有优先级,其优先级和运算优先级一样,所以我总结了一下其原则:从变量名处起,根据运算符优先级结合,一步一步分析.下面让我们先从简单的类型开始慢慢分析吧:int p;//这是一个普通的整型变量int*p;//首先从P处开始,先与*结合,所以说明P是一//个指针,然后再与int结合,说明指针所指向//的内容的类型为int型.所以P是一个返回整//型数据的指针int p[3];//首先从P处开始,先与[]结合,说明P是一个数//组,然后与int结合,说明数组里的元素是整//型的,所以P是一个由整型数据组成的数组int*p[3];//首先从P处开始,先与[]结合,因为其优先级//比*高,所以P是一个数组,然后再与*结合,说明//数组里的元素是指针类型,然后再与int结合,//说明指针所指向的内容的类型是整型的,所以//P是一个由返回整型数据的指针所组成的数组int(*p)[3];//首先从P处开始,先与*结合,说明P是一个指针//然后再与[]结合(与"()"这步可以忽略,只是为//了改变优先级),说明指针所指向的内容是一个//数组,然后再与int 结合,说明数组里的元素是//整型的.所以P 是一个指向由整型数据组成的数//组的指针int**p;//首先从P开始,先与*结合,说是P是一个指针,然//后再与*结合,说明指针所指向的元素是指针,然//后再与int 结合,说明该指针所指向的元素是整//型数据.由于二级指针以及更高级的指针极少用//在复杂的类型中,所以后面更复杂的类型我们就//不考虑多级指针了,最多只考虑一级指针.int p(int);//从P处起,先与()结合,说明P是一个函数,然后进入//()里分析,说明该函数有一个整型变量的参数//然后再与外面的int结合,说明函数的返回值是//一个整型数据int(*p)(int);//从P处开始,先与指针结合,说明P是一个指针,然后与//()结合,说明指针指向的是一个函数,然后再与()里的//int结合,说明函数有一个int型的参数,再与最外层的//int结合,说明函数的返回类型是整型,所以P是一个指//向有一个整型参数且返回类型为整型的函数的指针int*(*p(int))[3];//可以先跳过,不看这个类型,过于复杂//从P开始,先与()结合,说明P是一个函数,然后进//入()里面,与int结合,说明函数有一个整型变量//参数,然后再与外面的*结合,说明函数返回的是//一个指针,,然后到最外面一层,先与[]结合,说明//返回的指针指向的是一个数组,然后再与*结合,说//明数组里的元素是指针,然后再与int结合,说明指//针指向的内容是整型数据.所以P是一个参数为一个//整数据且返回一个指向由整型指针变量组成的数组//的指针变量的函数.说到这里也就差不多了,我们的任务也就这么多,理解了这几个类型,其它的类型对我们来说也是小菜了,不过我们一般不会用太复杂的类型,那样会大大减小程序的可读性,请慎用,这上面的几种类型已经足够我们用了.1、细说指针指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。
c语言指针教学中的知识点分析与总结
c语言指针教学中的知识点分析与总结c语言指针教学中的知识点分析与总结本文对c语言指针的教学进行了探讨和总结。
要想真正的掌握c 语言的指针，首先必须要对它有全面深刻的认识。
因为它是c语言的基础，只有将指针的知识学好，才能够更好地学习后续的课程。
下面小编给大家介绍一下关于c语言指针的知识。
一、 c语言中指针的定义指针是一种特殊的数据类型，也称为引用类型。
所谓指针就是指向一个地址的变量，例如： int a[10];二、变量指针及指针变量1.1 c语言中的变量。
变量是存储在计算机中的二进制数值，当我们需要使用时，必须创建一个变量并赋予它相应的值，然后将变量的地址传递给外部的一个或多个对象，这样外部对象通过访问内部变量来使用其中存储的信息，而且可以保证外部对象不会越界。
1.2指针变量是变量的一种特殊形式，指针变量在内存中占有一块区域，可以指向一个地址，这个地址的值是这个变量所代表的值，这样方便变量间的传递。
例如： char *a[10];2.1指针操作符2.2指针数组，它的作用和一维数组相同，即具有一维数组的特点，也具有二维数组的特点，三者最明显的区别就是二维数组中元素个数是固定的，而一维数组中元素个数是可变的。
2.3指针的运算规则。
在指针变量的操作中，要遵循以下运算规则：原地址→指针地址。
例如： char * a[10]; 2.4 c语言中的const指针常量是一种特殊的指针常量， const不是一种变量的标准类型，它专门用于指向一个const指针。
2.3指针的运算规则。
在指针变量的操作中，要遵循以下运算规则：原地址→指针地址。
例如： char *a[10];2.4指针的定义与使用：所谓指针就是指向一个地址的变量，例如： int a[10]; 2.4指针的定义与使用： pointer， pointer-pointer，and-and-and。
所以，当我们在一个字符串中出现pointer，pointer-pointer， and-and-and的时候，就表示它指向一个地址。
c语言中的指针详解
c语言中的指针详解在C语言中，指针是一种特殊的变量类型，它存储了一个变量的内存地址。
通过指针，我们可以间接访问和修改内存中的数据，这对于一些需要动态分配内存的操作非常有用。
以下是关于C语言指针的一些详细解释：1. 定义指针：使用"*"符号来定义指针变量。
例如，int* ptr; 定义了一个指向整型变量的指针 ptr。
2. 取址操作符(&)：取地址操作符(&)用于获取变量的内存地址。
例如，&a 返回变量 a 的地址。
3. 解引用操作符(*)：解引用操作符(*)用于访问指针所指向的变量的值。
例如，*ptr 返回指针 ptr 所指向的整型变量的值。
4. 动态内存分配：可以使用相关的库函数（如malloc和calloc）在运行时动态分配内存。
分配的内存可以通过指针来访问和使用，并且在使用完后应该使用free函数将其释放。
5. 空指针：空指针是一个特殊的指针值，表示指针不指向任何有效的内存地址。
可以将指针初始化为NULL来表示空指针。
6. 指针和数组：指针和数组在C语言中有密切的关系。
可以通过指针来访问数组元素，并且可以使用指针进行指针算术运算来遍历数组。
7. 传递指针给函数：可以将指针作为函数参数传递，以便在函数内部修改实际参数的值。
这种传递方式可以避免拷贝大量的数据，提高程序的效率。
8. 指针和字符串：字符串在C语言中实际上是以字符数组的形式表示的。
可以使用指针来访问和操作字符串。
需要注意的是，指针在使用时需要小心，因为不正确的操作可能导致程序崩溃或产生不可预料的结果。
对于初学者来说，理解指针的概念和使用方法可能需要一些时间和练习。
C语言指针详解
C语言指针详解1 程序如何运行当我们打开电脑中的任何一个程序运行时，我们的操作系统会将该程序存在硬盘的所有数据装载到内存中，然后有CPU 进行读取内存中的数据并进行计算，并将计算的结果返回给我们的操作系统，然后操作系统将相应的动作交付给相应的硬件来完成。
如：将声音数据交给声卡，最后有音响输出来，将图像交给显卡最后有显示器输出……但是还会有一部分数据会返回给内存，以供程序下面的语句继续使用。
我们都知道内存的容量有很大，如：4G，8G, 16G，有时候我们会打开很多的程序，所有的程序的数据都存放到我们的内存中，那么CPU是如何正确的读取我们的不同程序的数据并加以计算的哪？2 内存的假设设计为了让我们的CPU 可以很好的读取内存中的数据，内存必须做优化设计，于是给内存设定了集合设计，将我们的内存分成很多大小相同的方格（盒子），所有的数据将放入这些小盒子中，将不同的程序的数据放入到不同的小盒子中，这样就出现的模块化的内存，当我执行程序的一个命令时，CPU就会从相应的盒子读数据然后计算，由于我们硬件所能访问或计算的最小单位是字节，所以内存中的这样的一个小盒子的大小就给他规定一个字节。
3 地址和指针一般我们声明一块内存空间的时候，会给他取一个名字，为的是我们在编写程序的时候方便使用空间中存放的值，但是CPU 读数据的时候会忽视这个名字，因为CPU无法理解这样的数据，CPU 只能执行0,1代码，那么CPU是如何知道从什么地方读取数据，又到什么地方地址数据的读取的那，所以必须对内存做2次设计，就是将内存中分成的很多小盒子下面标注一些顺序的序号，例如：从第一个盒子开始，标注1,2,3,4,5,6,7，……每一个数字对应一个盒子，但是真正的内存如中不是使用这些十进制数字的，而是使用16进制整数表示的，如0x16ffee。
这些我们标记的数字就叫做内存中的地址。
由于这些地址和盒子是对应的关系，所以只要知道了地址，就可以得到对应盒子中存放的数据了，形象的说，我们说这个地址指向对应的盒子，在C语言中可以通过地址得到对应盒子的数据是*地址。
C语言指针用法详解
C语言指针用法详解C语言指针用法详解指针可以说是集C语言精华之所在，一个C语言达人怎么可以不会指针呢。
下面店铺给大家介绍C语言指针用法，欢迎阅读!C语言指针用法详解(1)关于指针与数组的存储a、指针和数组在内存中的存储形式数组p[N]创建时，对应着内存中一个数组空间的分配，其地址和容量在数组生命周期内一般不可改变。
数组名p本身是一个常量，即分配数组空间的地址值，这个值在编译时会替换成一个常数，在运行时没有任何内存空间来存储这个值，它和数组长度一起存在于代码中(应该是符号表中)，在链接时已经制定好了;而指针*p创建时，对应内存中这个指针变量的空间分配，至于这个空间内填什么值即这个指针变量的值是多少，要看它在程序中被如何初始化，这也决定了指针指向哪一块内存地址。
b、指针和数组的赋值与初始化根据上文，一般情况下，数组的地址不能修改，内容可以修改;而指针的内容可以修改，指针指向的内容也可以修改，但这之前要为指针初始化。
如：int p[5];p=p+1; 是不允许的而p[0]=1; 是可以的;//int *p;p=p+1; 是允许的p[0]=1; 是不允许的，因为指针没有初始化;//int i;int *p=&i;p[0]=1; 是允许的;对于字符指针还有比较特殊的情况。
如：char * p="abc";p[0]='d'; 是不允许的为什么初始化了的字符指针不能改变其指向的内容呢?这是因为p 指向的是“常量”字符串，字符串"abc"实际是存储在程序的静态存储区的，因此内容不能改变。
这里常量字符串的地址确定在先，将指针指向其在后。
而char p[]="abc";p[0]='d'; 是允许的这是因为，这个初始化实际上是把常量直接赋值给数组，即写到为数组分配的内存空间。
这里数组内存分配在先，赋值在后。
(2)关于一些表达式的含义char *p, **p, ***p;char p[],p[][],p[][][];char *p[],*p[][],**p[],**p[][],*(*p)[],(**p)[],(**p)[][];能清晰地知道以上表达式的含义吗?(知道的去死!)第一组：char *p, **p, ***p;分别为char指针;char*指针，即指向char*类型数据地址的指针;char**指针，即指向char**类型数据的指针;他们都是占4字节空间的指针。
c语言指针的用法
c语言指针的用法c语言是一种高级编程语言，它可以直接操作内存中的数据。
指针是c语言中一种特殊的变量，它可以存储另一个变量的地址，也就是内存中的位置。
通过指针，我们可以间接地访问或修改内存中的数据，从而实现更高效和灵活的编程。
本文将介绍c语言指针的基本概念、定义和初始化、运算和应用，以及一些常见的错误和注意事项。
希望本文能够帮助你掌握c语言指针的用法，提高你的编程水平。
指针的基本概念指针是一种数据类型，它可以存储一个地址值，也就是内存中某个位置的编号。
每个变量在内存中都有一个唯一的地址，我们可以用指针来记录这个地址，然后通过这个地址来访问或修改变量的值。
例如，假设有一个整型变量a，它的值为10，它在内存中的地址为1000（为了简化，我们假设地址是十进制数）。
我们可以定义一个指向整型的指针p，并把a的地址赋给p，如下所示：int a =10; // 定义一个整型变量a，赋值为10int*p; // 定义一个指向整型的指针pp =&a; // 把a的地址赋给p这里，&a表示取a的地址，也就是1000。
p = &a表示把1000赋给p，也就是让p指向a。
从图中可以看出，p和a是两个不同的变量，它们占用不同的内存空间。
p存储了a的地址，也就是1000。
我们可以通过p 来间接地访问或修改a的值。
指针的定义和初始化指针是一种数据类型，它需要在使用前进行定义和初始化。
定义指针时，需要指定它所指向的变量的类型。
初始化指针时，需要给它赋一个有效的地址值。
定义指针的一般格式为：type *pointer_name;其中，type表示指针所指向的变量的类型，如int、char、float等；pointer_name表示指针的名称，如p、q、ptr等；*表示这是一个指针类型。
例如：int*p; // 定义一个指向整型的指针pchar*q; // 定义一个指向字符型的指针qfloat*ptr; // 定义一个指向浮点型的指针ptr注意，在定义多个指针时，每个指针前都要加*号，不能省略。
C语言指针知识点总结
C语⾔指针知识点总结1.指针的使⽤和本质分析（1）初学指针使⽤注意事项1）指针⼀定要初始化，否则容易产⽣野指针（后⾯会详细说明）；2）指针只保存同类型变量的地址，不同类型指针也不要相互赋值；3）只有当两个指针指向同⼀个数组中的元素时，才能进⾏指针间的运算和⽐较操作；4）指针只能进⾏减法运算，结果为同⼀个数组中所指元素的下表差值。
（2）指针的本质分析①指针是变量，指针*的意义：1）在声明时，*号表⽰所声明的变量为指针。
例如：int n = 1; int* p = &n;这⾥，变量p保存着n的地址，即p<—>&n，*p<—>n2）在使⽤时，*号表⽰取指针所指向变量的地址值。
例如：int m = *p;②如果⼀个函数需要改变实参的值，则需要使⽤指针作为函数参数（传址调⽤），如果函数的参数数据类型很复杂，可使⽤指针代替。
最常见的就是交换变量函数void swap(int* a, int* b)③指针运算符*和操作运算符的优先级相同例如：int m = *p++;等价于：int m= *p; p++;2.指针和数组（1）指针、数组、数组名如果存在⼀个数组 int m[3] = {1,2,3};定义指针变量p，int *p = m（这⾥m的类型为int*，&a[0]==>int*）这⾥，其中，&m为数组的地址，m为数组0元素的地址，两者相等，但意义不同，例如：m+1 = (unsigned int)m + sizeof(*m)&m+1= (unsigned int)(&m) + sizeof(*&m)= (unsigned int)(&m) + sizeof(m)m+1表⽰数组的第1号元素，&m+1指向数组a的下⼀个地址，即数组元素“3”之后的地址。
等价操作：m[i]←→*(m+i)←→*(i+m)←→i[m]←→*(p+i)←→p[i]实例测试如下：1 #include<stdio.h>23int main()4 {5int m[3] = { 1,2,3 };6int *p = m;78 printf(" &m = %p\n", &m);9 printf(" m = %p\n", m);10 printf("\n");1112 printf(" m+1 = %p\n", m + 1);13 printf(" &m[2] = %p\n", &m[2]);14 printf(" &m+1 = %p\n", &m + 1);15 printf("\n");1617 printf(" m[1] = %d\n", m[1]);18 printf(" *(m+1) = %d\n", *(m + 1));19 printf(" *(1+m) = %d\n", *(1 + m));20 printf(" 1[m] = %d\n", 1[m]);21 printf(" *(p+1) = %d\n", *(p + 1));22 printf(" p[1] = %d\n", p[1]);2324return0;25 }输出结果为：（2）数组名注意事项1）数组名跟数组长度⽆关；2）数组名可以看作⼀个常量指针；所以表达式中数组名只能作为右值使⽤；3）在以下情况数组名不能看作常量指针：- 数组名作为sizeof操作符的参数- 数组名作为&运算符的参数（3）指针和⼆维数组⼀维数组的指针类型是 Type*，⼆维数组的类型的指针类型是Type*[n]（4）数组指针和指针数组①数组指针1）数组指针是⼀个指针，⽤于指向⼀个对应类型的数组；2）数组指针的定义⽅式如下所⽰：int (*p)[3] = &m;②指针数组1）指针数组是⼀个数组，该数组⾥每⼀个元素为⼀个指针；2）指针数组的定义⽅式如下所⽰：int* p[5];3.指针和函数（1）函数指针函数的本质是⼀段内存中的代码，函数的类型有返回类型和参数列表，函数名就是函数代码的起始地址（函数⼊⼝地址），通过函数名调⽤函数，本质为指定具体地址的跳转执⾏，因此，可定义指针，保存函数⼊⼝地址，如下所⽰：int funcname(int a, int b);int(*p)(int a, int b) = funcname;上式中，函数指针p只能指向类型为int(int,int)的函数（2）函数指针参数对于函数int funcname(int a, int b);普通函数调⽤ int funcname(int, int)，只能调⽤函数int func(int, int)函数指针调⽤ intname(*func)(int,int)，可以调⽤任意int(int,int)类型的函数，从⽽利⽤相同代码实现不同功能，实例测试如下，假设有两个相同类型的函数func1和func2：1int func1(int a, int b, int c)2 {3return a + b + c;4 }56int func2(int a, int b, int c)7 {8return a - b - c;9 }普通函数调⽤和函数指针调⽤⽅式及结果如下所⽰1 printf("普通函数调⽤\n");2 printf("func1 = %d\n", func1(100, 10, 1));3 printf("func2 = %d\n", func2(100, 10, 1));4 printf("\n");56 printf("函数指针调⽤\n");7int(*p)(int, int, int) = NULL;8 p = func1;9 printf("p = %d\n", p(100, 10, 1));10 p = func2;11 printf("p = %d\n", p(100, 10, 1));12 printf("\n");需要注意的是，数组作为函数参数的时候，会变为函数指针参数，即:int funcname( int m[] )<——>int funcname ( int* m )；调⽤函数时，传递的是数组名，即funcname(m);（3）回调函数利⽤函数指针，可以实现⼀种特殊的调⽤机制——回调函数。
指针的详细讲解
指针的详细讲解
指针是C语言中重要的概念，也是很多初学者比较困惑的一部分。
在C语言中，指针是一个特殊的数据类型，它直接或者间接地指向了另一个变量或者数据的地址。
指针的基本定义：指针是一个变量，其值是扮演着另一个变量名也就是地址的变量的地址。
指针与变量之间的区别在于，变量存储的是实际的值，而指针存储的是值的内存地址。
指针的类型：在C语言中，指针有不同的类型，这些类型标识了指针指向的变量的数据类型。
例如，int*是一个整数指针，而char*是一个字符指针。
指针的运算：指针可以进行加、减、前后移动等操作。
例如，指针加上一个整数就会指向另一个地址，指针减去一个整数就会回到前一个地址。
指针的使用：指针的主要作用是通过引用来访问变量或者数据。
通过指针，我们可以传递变量的地址而不是变量本身，这样可以减少内存的使用量并提高程序的效率。
指针的注意事项：在使用指针时，需要特别注意指针的安全性。
不正确的使用指针可能会导致内存泄漏、程序崩溃、数据丢失等问题。
总的来说，指针是C语言中一个非常重要的概念，理解它的基本概念和使用方法，对于C语言的学习和开发都有非常重要的意义。
C语言之指针
指针一、指针的概念指针即地址，一个变量的指针就是指该变量的地址。
注意：指针变量中只能存放地址。
二、指针变量的定义和引用1、指针变量的定义int *p; 此语句定义了一个指针变量p，p中可存放一个整型变量的地址。
注意：①*是指针变量的特征②只是分配了一个存储单元，并没有指真正指向，要想使一个指针变量指向一个整型变量必须赋值。
例如：：int *p,I=3;p=&I;如果p=3就是错误的。
2、指针变量的引用（两个有关指针的运算符）①& 取地址运算符号②* 指针运算符*p表示p所指向的变量值。
int *p,a;p=&a; /*指向变量a的值赋给p*/scanf(“%d”,p);/*从键盘输入一个值赋值给p所指向的变量a*/*p=5; /*把5赋值给变量p所指向的a*/三、指针作为函数参数函数的参数不仅可以是整型、实型、字符型等数据，还可以是指针类型，它的作用是将一个变量的地址传送到另一个函数中四、指针与数组1、一维数组的指针表示方法（1）数组中各元素的地址。
int a[10]={1,2,3,4,5,6,7,8,9,10};①&a[0] &a[1] &a[2] 、、、&a[i]、、、&a[9]②a a+1 a+2 、、、a+i、、、、、a+9（2）数组元素值①a[0] a[1] a[2] 、、、、a[i]、、、、a[9]②*(a+0) *(a+1) *(a+2)、、*(a+i) *(a+9)2、二维数组的指针表示方法例：int a[3][4]={1,2,3,4,5,6,7,8,9,10,11,12};1、每行的起始地址①&a[0][0] &a[1][0] &a[2][0]②a[0] a[1] a[2]③a+0 a+1 a+2④*a *(a+1) *(a+2)⑤&a[0] &a[1] &a[2]2、各元素的地址①&a[0][0] &a[0][1] &a[0][2]②a[0]+1 a[0]+2 a[1]+2③*a+1 *(a+1)+1 *(a+2)+23、各元素的值①*(&a[0][0]) *(&a[0][1]) *(&a[0][2])②*(a[0]+1) *(a[0]+2) *(a[1]+2)③*(*a+1) *(*(a+1)+1) *(*(a+2)+2)四、指针与数组;printf(“%d”,*p);注意：int (*p)[5]表示p是指针变量，它指向一个包含5个元素的一维数组int *p[5] 是指针数组。
C语言指针讲解
float a;
int * pointer_1;
pointer_1=&a;
编辑课件
9
在对指针变量赋值时需要注意两点：
⑴ 指针变量中只能存放地址（指针），不要将一个 整数赋给一个指针变量。
例: * pointer_1＝１００； /* pointer_1是指针 变量,１００是整数，不合法 */
(2) 赋给指针变量的变是量地址不能是任意的类型， 而只能是与指针变量的基类型具有相同类型的变 量的
编辑课件
22
可以用一个指针变量指向一个数组元素。
例如：ｉｎｔ ａ［１０］； (定义ａ为包含１０个整型数据的数组)
ｉｎｔ *ｐ； (定义ｐ为指向整型变量的指针变量)
ｐ＝＆ａ［０］； (把ａ［０］元素的地址赋给指针变量ｐ) 也就是使ｐ指向ａ数组的第０号元素 。
编辑课件
23
编辑课件
24
10.3.2 指针的运算
编辑课件
29
(3) 用指针变量指向数组元素。
#include <stdio.h> void main（） ｛ int ａ［１０］；
int *ｐ，ｉ； for（ｉ＝０；ｉ＜１０；ｉ＋＋）
scanf（″％ｄ″，＆ａ［ｉ］）； printf（″＼ｎ″）； for（ｐ＝ａ；ｐ＜（ａ＋１０）；ｐ＋＋）
printf（″％ｄ ″，*ｐ）； ｝
｛ void exchange（int *ｑ1， int *ｑ2， int *ｑ3）;
int ａ，ｂ，ｃ，*ｐ１，*ｐ２，*ｐ３；
scanf（″%ｄ，%ｄ，%ｄ″，&ａ, &ｂ, &ｃ）；
ｐ１＝＆ａ；ｐ２＝＆ｂ；ｐ３＝＆ｃ；
exchange （ｐ１，ｐ２，ｐ３）；
c语言指针基础篇自学笔记1
c语言指针基础篇自学笔记1
指针(pointer)是C语言中的一种特殊数据类型，它存储的是一个指向另一个变量的地址。
指针变量是一个存储地址的变量，而不是存储值的变量。
指针变量的定义方式为：数据类型 *指针变量名;
例如：int *p;
其中，int是数据类型，*表示指针变量，p是指针变量名。
2.如何使用指针
指针的主要作用是通过地址访问变量的值。
通过指针，可以实现函数间的变量共享和动态内存分配。
使用指针的步骤如下：
1）声明指针变量；
2）将变量的地址赋给指针变量；
3）通过指针变量访问变量的值。
3.指针与数组
指针和数组在C语言中是密不可分的。
在使用数组时，可以使用指针来访问数组元素。
例如：int scores[5] = {80, 90, 85, 75, 95};
int *p = scores;
其中，p指向scores数组的第一个元素80，可以通过p访问数组的所有元素。
4.指针和函数
指针和函数结合使用能够实现函数间的变量共享。
在函数中，可
以通过指针修改函数外部的变量的值。
例如：void swap(int *a, int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
在调用swap函数时，传递的是变量的地址，函数内部通过指针修改变量的值。
5.指针的高级应用
指针有许多高级应用，例如指针的指针、指针的数组、动态内存分配等。
学习这些高级应用需要更深入的C语言知识和经验。
以上是C语言指针基础篇自学笔记1的内容，希望对初学者有所帮助。
C语言基础知识函数指针指针函数(定义格式作用及用法说明)
C语言基础知识函数指针指针函数（定义格式作用及用法说明）函数指针（Function Pointers）是C语言中一种特殊的指针，它可以指向一个函数。
不同于普通指针，函数指针表示指向一个函数的入口地址，而且可以在运行时动态改变。
函数指针可以用来实现函数的参数传递、函数的地址调用、函数的回调机制以及多态等功能。
一、定义格式函数指针可以像普通指针一样进行定义，只不过指针的指向类型不是普通的数据类型，而是函数，它的定义格式如下：（1）一般的函数指针：<return_type> (*ptr)(param_list);（2）函数指针数组：<return_type> (*ptr)(param_list)[size];（3）函数指针数组指针：<return_type> (*ptr[size])(param_list);（4）带参数的函数指针：<return_type> (*ptr)(type param);（5）可变参数的函数指针：<return_type> (*ptr)(param_type, ...)；（6）函数指针的指针：<return_type> (**ptr)(param_list);二、作用（1）函数指针可以在函数内外传递，从而可以实现函数参数的传递，实现函数的“回调”机制；（2）函数指针可以用来实现回调函数，比如设计回调函数时，可以将函数指针作为参数，当一些事件发生时，函数指针被调用，来执行特定的操作；（3）函数指针可以实现函数的多态，函数指针可以用来指向不同参数类型的函数，从而实现函数的多态。
三、用法。
C语言指针
#include <stdio.h>
void main()
{ int a=5,b=3;
int *p;
10
p=&a;
4,4
b=*p+5;
printf(“%d\n”,b);
*p=4;
printf(“%d,%d”,a,*p);
}
三、数组的指针与函数实参
例：编写一函数求一维数组的最大元素及其下 标位置（要求使用指针） 已知：数组首地址p，元素个数n；（作函数参 数） 结果：下标k；（作返回值） int max_array(int *p,int n) 设最大值放在max中，则初始状态为：
max=*p, k=0 如果*(p+i)>max 则max=*(p+i)且k=i
a[i] &a[i][0] *(a+i)
数组元素地址
a+i &a[i]
不要把&a[i]理解为a[i]单元的物理地址,因为 a[i]不是一个变量, &a[i] 和a[i]的值是相等的。但 含意不一样。前者指向行，后者指向列； &a[i]:第i行的首地址 a[i]:第i行0列地址 &a[i]+1:第i+1行的首地址 a[i]+1:第i行1列的地址
指针变量作函数参数
例：编写一个函数实现两个数的交换。
#include<stdio.h>
#include<stdio.h>
void swap(int x,int y) void swap(int *x,int *y)
C语言6-指针
int a; int *p1; 指针p1 变量a
&a 目标变量p1
P1=&a;
&运算和*运算
&运算和*运算都属于单目运算，&要求运算量是变量或数
组元素，(取地址运算符)其形式为: & 变量名或数组元素名 其含义为取指定变量或数组元素的地址 *运算符要求运算量是地址，（指针运算符——间址运 算符）其形式为： *指针变量名或目标变量地址 含义为访问指定地址的目标变量 如： int i , j; int *p_1 , *p_2; p_1=&i; p_2=&j;
可见，指针p±n的运算并非内存地址含义上的运 算，而是C语言含义的地址运算。这种运算，一般 应在相同数据类型的存储区域上操作才有实际意 义，因此指针和数组关系密切，后图表示了这种 情况。
int a[40],*pa; pa-4 pa-3 pa-2 pa-1 pa pa+1 pa+2 pa+3 pa+4 a[ i –4] a[ i –3] a[ i –2] a[ i -1] a[ i ] a[i+1] a[i+2] a[i+3] a[i+4] (pa-4) (pa-3) (pa-2) (pa-1) pa (pa+1) (pa+2) (pa+3) (pa+4) 2004 2006 2008 2010 2012 2014 2016 2018 2020
运行情况如下： a=5,b=9 max=9,min=5
注： 程序中，a和b的值并未改变，但a1、a2的值已经改变， 因为程序始终让a1指向较小者，a2指向较大者，算法采取不 交换整型变量的值而交换指针变量的值的方法。 使用指针处理数据时，指针在使用前必须被赋予一定的地址 值或指定为空指针。一个没有赋值的指针其指向是不定的。 使用指针未定的指针接收数据时，常常会破坏内存中其它领 域的内容，甚至造成系统失控，应注意避免。例如下面对指 针p的使用是不恰当的：
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
指针★指针的重要性表示一些复杂的数据结构快速传递数据使函数返回一个以上的值能直接访问硬件能方便处理字符串是理解面向对象语言中引用的基础总结：指针是C 语言的灵魂★指针的定义 ☆地址内存单元的编号 从零开始的非负整数 范围：4G ☆指针1.指针就是地址，地址就是指针2.指针变量是存放地址的变量3.指针和指针变量是两个不同的概念4.叙述时通常把指针变量简称为指针，实际它们含义不一样5.指针的本质就是一个操作受限的非负整数 ★指针的分类☆基本类型指针（重要） #include<stdio.h> int main(void)Int f(int i,int j){return 100;// return 88;error }Int main (void){Int a=3,b=5;# include <stdio.h> Void g(int*p,int*q){*p=1;*q=2; } Int main(void) {Int a=3,b=5;{int *p; //p是变量的名字，int*表示p变量存放的是int类型变量的地址Int*p;不表示定义了一个名字叫做*p的变量Int*p;应该理解为：p是变量名，p变量的数据类型是int*类型所谓int*类型，实际就是存放int变量地址的类型int i=3;char ch=’A’p=&i; //OK1.p保存了i的地址，因此p指向i2.p不是i，i也不是p，修改p的值不影响i的值，修改i的值也不影响p的值3.如果一个指针变量指向了某个普通变量，则*指针变量完全等同于普通变量例：若p指向i，则*p=i (*p和i 可互相替换)p=&ch;//error//p=i; //error,因为类型不一致，p只能存放int类型变量的地址，不能存放int类型变量//P=55;//error,原因同上return 0；}△附注：?*的含义：1.乘法2.定义指针变量Int*p; //定义了一个名字叫做p的变量，int*表示p只能存放int变量的地址3.指针运算符该运算符放在已经定义好的指针变量的前面如果p是一个已经定义好的指针变量则*p 表示以p 的内容为地址的变量 ?如何通过被调函数修改主调函数普通变量的值 1.实参必须为该普通变量的地址 &... 2.形参必须为指针变量 *...3.在被调函数中通过 *形参名=...... 的方式就可以修改主调函数相关变量的值 例子： 经典指针程序：互换数值形参和实参是不同的变量，修改形参不会改变实参 ?指针常见错误 #include<stdio.h> Int main(void) { Int i=5; Int*p; Int*q; P=&i;//*q=p;//error 语法编译会出错 //*q=*p;//errorP=q;//q 是垃圾值，q 赋给p ，p 也是垃圾值 printf(“%d\n ”,*q); //13行/*q 的空间是属于本程序的，所以本程序可以读写q 的内容，但是如果q 内部是垃圾值，则本程序不能读写*q 的内容因为此时*q 所代表的内存单元的控制限权并没有分配给本程序 所以本程序运行到13行时就会立即出错*/ return 0;#include<stdio.h>void huhuan （int a, int b ） { int t; t=a; a=b; b=t; return; }int main(void) { int a=3; int b=5;huhuan(a,b);#include<stdio.h> void huhuan2（int *p, int *q ） {int *t;//如果要互换p 和q 的值， 则t 必须是int*，不能是int t=p; p=q; q=t; return;}int main(void){int a=3;int b=5; #include<stdio.h>void huhuan3（int *p, int*q ） //形参的名字是p 和q ，接收实参数据的是p 和q ，而不是*p 和*q{int t;//如果要互换*p 和*q 的值， 则t 必须是int ，不能是int* t=*p;//p 是int*，*p 是int *p=*q; *q=t; return; }int main(void) {int a=3;int b=5;}☆指针和数组△指针和一维数组 ?一维数组名一维数组名是个指针常量它存放的是一维数组第一个元素的地址 ?下标和指针的关系如果p 是个指针变量，则p[i]永远等价于*(p+i) ?确定一个一维数组需要几个参数（如果一个函数要处理一个一维数组，则需要接收该数组的哪些信息） 需要两个参数：数组第一个元素的地址 数组的长度?指针变量的运算 指针变量不能相加，不能相乘，不能相除 可以相减（仅当两个指针变量指向的是同一块连续空间中的不同存储空间） ?一个指针变量到底占几个字节 预备知识： sizeof （数据类型）功能：返回值就是该数据类型所占的字节数例子：sizeof （int ）=4 sizeof （char ）=1 sizeof （double ）=8 # include<stdio.h>//f 函数可以输出任何一个一维数组的内容 void f(int * pArr, int len) { int i ； for(i=0,i<len,++i) printf( “%d ”,*(pArr+i) ) //*(pArr+i)等价于pArr[i] b[i] *(b+i) int main(void){ int a[5]={1,2,3,4,5}; int b[6]={-1,-2,-3,4,5,-6};int c[100]={1,99,22,33}; f(a,5);//a 是int*f(b,6); 1 2 3 4 5 -1 -2 -3 4 5 -61 99 22 33 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 # include<stdio.h>void f(int * pArr,int len) { pArr[3]=88; //10行} int main(void) { int a[6]={1,2,3,4,5,6} printf(“%d\n ”,a[3]); //17行 f(a,6); printf(“%d\n ”,a[3]); //19行 若写为&a[3]则输出结果为a[3]的地址 #include<stdio.h> Int main(void){ int i=5;Int j=10; Int*p=&i; #include<stdio.h> Int main(void) { int i=5; Int j=10; Int*p=&i; Int*q=&j; Int a[5]; p=&a[1];#include<stdio.h>Void f(int*pArr,int len){ pArr[2]=10; //pArr[2]==*( pArr+2)==*(a+2)==a[2]}Int main(void) { int a[6]={1,2,3,4,5,6} printf(“%d\n ”,a[2]);f(a,5);printf(“%d\n ”,a[2]); //a=&a[2];//error 因为a 是常量# include<stdio.h> Void OutArr(int*pArr,int len) {Int i; For(i=0;i<len;++i)Printf(“%d\n ”,pArr[i]);}Int main(void) { OutArr(a,5);Return 0; }sizeof （变量名）功能：返回值是该变量所占的字节数 假设p 指向char 类型变量（1个字节） 假设q 指向int 类型变量（4个字节） 假设 r 指向double 类型变量（8个字节）△指针和二维数组☆指针和函数 ☆指针和结构体 ☆多级指针 专题：动态内存分配（重难点）传统数组的缺点：1.数组长度必须事先制定，且只能是常整数，不能是变量。
例子：int a[5]; //OKInt len=5; int a[len];//error Int a[5.6];//error2.传统形式定义的数组，该数组的内存程序员无法手动释放 为什么需要动态分布内存动态内存分配举例-动态数组的构造 静态内存和动态内存的比较 跨函数使用内存的问题#include<stdio.h>Int main(void) { char ch=’A ’; Int i=99; Double x=66.6 Char * p=&ch;Int *q=&i; 4 4 4Press any key to continue。