在c语言中,任何一个变量,都有两层含义:
(1) 代表该变量的存储单元的地址;变量的地址 左值 lvalue
(2) 代表该变量的值;右值 rvalue
对于一个变量的访问,只有两种情况:
一是把一个值写到变量的地址中去 (lvalue)
二是从变量的地址中取变量的值 (rvalue)
对象的访问方式
直接访问 : 通过对象名去访问
如:
int a; a = 1024; b = a;
注:直接访问 受到作用域的限制
间接访问 :
通过对象的地址去访问,指针访问。
只要你知道了对象的地址,就可以在任何地方去访问它。
不受作用域的限制。
什么是指针
存储单元(如: memory 内存)的地址:
分配给每个对象的内存单元都有一个编号,这个编号就是我们所说
存储单元的地址。并且存储单元按照字节来编号。
在c语言中,指针的概念与地址差不多的,你可以直接认为指针就是一个地址。
一个变量的地址,我们也称为变量的“指针”
& 取地执符
单目运算符, “取xxx对象的地址”
通过一个对象的指针去访问它,首先要解决对象的指针(地址) 的保存问题。
需要定义另外的一个变量去保存它的地址,这种变量我们称为指针变量。
指针变量
指针变量也是一个变量,也是用来保存数据,只不过指针变量保存的数据是其他对象的地址。
指针变量的定义:
指向的对象的类型 * 指针变量名;
“指向的对象的类型” :
指针变量指向的对象的类型,而不是指针的类型。
如:
int *p; int a=10; p=&a;//p保存了对象a的地址 // p 指向 a
与指针相关的运算符
& : 取地址符
int a;
&a : 表示取对象a的地址
对象a的地址,其实就是对象a的指针。
* : 指向运算符 ,单目运算符
*地址(*指针): 地址对应的那个变量(对象)。
如
int a=10; int *p=&a; int b=*&a;//b=10,int b=a
所以*(&a) <=> a
*& 可以直接约掉 (编译原理状态机的词法分析)
指针变量作为函数参数
传递的还是值!! 只不过这个“实参的值”可能是某个对象的地址!
c语言中,函数参数的传递只能是"值传递"
形参 = 实参的值
野指针:
void xxx2(int * m, int * n) { int * t;//定义了一个指针变量t, 但是t没有被赋值 //t没有赋值,但是不代表它没有值,相反它会有一个相对应的 //不知道这个值是多少 undefine *t = *m; //操作野指针,可能导致 段错误(对一个未知的空间进行写操作) *m = *n; *n = *t; //操作野指针,可能导致 段错误(对一个未知的空间进行读操作)
*t 放置到 ‘=’ 符号的左边,代表t指向对象的左值
对t的指向的对象进行写的操作
*t 放置到 ‘=’ 符号的右边,代表t指向对象的右值
对t的指向的对象进行read的操作
所以t是一个“野指针”,我们也不知道 t指向的内存空间是否可读可写,
如果不可读或者不可写,那么后续对*t操作,就会导致内存的非法访问 => 段错误!!
空指针:
null 0
在计算机中地址为0的存储空间是不存在的
如果一个指针的值,指向空(null)的指针,称之为空指针。
int *p=null; *p=1024;//操作空指针 int b=*p;//操作空指针
我们去使用空指针,一定会 造成内存的非法访问 => 段错误
数组与指针
数组元素与普通变量是一样的,数组元素也有自己的地址。
数组元素也有左值和右值,并且数组元素间的地址是相邻的。
数组名可以代表首元素的地址。
a => &a[0], 数组名a当做指针来看
如
int a[]={1,2,3}; int *p=a;//a是数组名当指针来看,==&a[0]
指针作加减的问题:
能不能通过指针p去访问a[1]?
p=p+1;//&a[0]+1==&a[1]
p + i (p是一个指针,i是一个整数值)
注:不是简单地加减数值,而是加减i个指针指向单元的长度。
p + 1 => 往后面挪了一个int单元的长度 ,&a[1]
int a[10]; int * p = a; // p = &a[0] a[1] <=> *&a[1] <=> *(&a[0] + 1) <=> *(a + 1) <=> a[1] a[1] <=> *&a[1] <=> *(&a[0] + 1) <=> *(p + 1) <=> p[1]
数组名a,在代码中有两层含义:
int a[10];
(1) 数组名代表整个数组
&a : 取整个数组a的地址。
&a + 1 : 往后面挪了1个(int[10])单元长度。
(2) 在合适情况下面,数组名可以当作指针来看
a <=> &a[0]
a + 1 : 当作指针来看
=> &a[0] + 1
=> &a[1]
多维数组与指针
在c语言中,所有的数组其实都是一维数组!
int a[3][4]; //int[4] a[3];
表达式 表达式的含义 表达式的值
a 数组名:
(1) 当作指针 &a[0] 取整个一维数组a[0]的地址
(2) 当作整个数组来看
a[0] 数组名:
(1) 当作指针 &a[0][0] 取数组元素a[0][0]的地址
(2) 当作整个一维数组a[0]来看
a[0][0] 数组元素a[0][0] a[0][0] (左值/右值)
a + 1 a是数组名,在此处当作指针 ==&a[0]+1==&a[1]
a[0] + 1 a[0] 是数组名,在此处当作指针 ==&a[0][0]+1==&a[0][1]
a[0][0] + 1 a[0][0]是二维数组a中的一个int类型的元素 ==a[0][0]+1
a[1] + 2 a[1]是数组名,此处当作指针 ==&a[1][0]+2==&a[1][2]
*(a + 1) + 2 a是数组名,在此处当作指针 ==*(&a[0]+1)+2==*(&a[1])+2==a[1]+2==&a[1][2]
指针常量 和 常量指针
他们都是指针,只不过他们之间的属性有一点区别。
指针常量:
指针本身不能改变(指针的指向不能变),但是
它所指向的内存空间里面的内容是可以改变的。
最具有代表性例子,数组名!
定义方式:
指向对象的类型 * const 指针变量名;
int a , b; int * const p = &a; p = &b ; //error
常量指针:
是一个指向常量的地址。指针指向的对象是常量,
那么指针本身的指向是可以改变的,但是这个指针指向
内存空间中的内容是不能够改变。
最具有代表性例子,字符串
char * p = "abcde"; //"abcde" <=> &'a'
定义方式:
const 类型 * 变量名;
or
类型 const * 变量名;
指针数组 与 数组指针
(1) 指针数组
指针数组是一个数组,只不过它里面的每一个元素都是指针罢了!
定义数组:
数组元素类型 数组名[元素个数];
“数组元素类型” : c语言中任意合法的类型都可以。
int * p[4]; //定义了一个指针数组,数组名为p,里面含有4个int*类型的指针。
(2) 数组指针
数组指针是一个指针,只不过这个指针是用来指向一个数组罢了!!
int (*p)[4] ; //定义了一个数组指针,指针变量名为p,用来指向一个含有4个int类型元素的数组的。
如
int a[3][4]; int (*p)[4]; p = a; //&a[0] *(*p + 1) // *(a[0]+1)==*(&a[0][1])==a[0][1] *(*(p + 2)) // *(*(&a[2]))==*(&a[2][0])==a[2][0] *(*(p+3) + 3)// *(*(&a[0]+3)+3)==*(*(&a[3])+3)==*(&a[3][0]+3)==a[3][3]
字符串与指针
字符串就是一串字符。在c语言中,没有字符串这个类型。
c语言字符串是通过 char *(字符指针)来实现。
c语言中的字符串,是用""引起来的一串字符来表示,并且字符串后面默认会加一个 , (ascii为0的那个字符)字符串结束的标志。
如
"abc" //字符串
"n" //字符串
"" //字符串 => 空串
'123' //字符
'n' //字符
注:
我们只需要保存字符串的首字符地址就可以了,从首字符地址开始找到第一个 ,前面的这些字符就是字符串里面的字符。
在c语言中的字符串(如: “ssssssabcd”)是保存在一个叫做 .rodata(只读数据)的内存区域,字符串代表是这个内存空间的首地址。
"ssssssabcd" => 表达式的值 => &'s' char *p="12345" ==&'1' int *p=&'1'; p+1=&'2';
字符数组:
char s[5] = {'a', 'b', 'c', 'd', 'e'}; //字符数组,与普通数组是一样的,保存在一个.data/栈空间 //数组区域是可读可写的 sizeof(s) == 5 strlen(s) >= 5 //没有' ' 长度不确定
char s[] = {"abcde"}; //自动生成' ' <=> char s[] = {'a', 'b', 'c', 'd', 'e', ' '}; //s字符数组,与普通数组是一样的,保存在一个.data/栈空间 //数组区域是可读可写的 sizeof(s) == 6 strlen(s) == 5
char s[] = {"abcde"}; s[1] = 'b'; //ok char ch = s[1]; //ok *(s + 1) = 'b'; //ok ch = *(s + 1); //ok s = s + 1; //error //s是数组名,数组名当作指针,指针常量 //s的指向 是不能够改变的,但是s指向的内存空间 //里面的内容是可变的 printf("%sn", s); //abcde %s : char* 地址 //把后面的那个地址当作是一个字符串的首地址,一个一个字符进行输出,直到遇到 才会结束!
函数指针
函数也有地址 ,那么咱们可以定义一个指针,去存放一个函数的地址,像这样的指针,称为函数指针。
函数指针如何定义
int * abc(int a, float b) { }
描述函数abc的类型: int (int , float ) : 是一个返回值为int类型,带有一个int类型和float类型的参数的函数类型
指向函数的返回值的类型 (*指针变量名) (指向函数的形参类型列表);
int (* p)(int, int) ;
定义了一个指针变量p,p是一个函数指针,是用来指向一个返回值为int类型,并且带有两个int类型参数的函数的。
函数指针如何赋值
&函数名
or
函数名 : 在c语言中,函数名本身就可以代表函数的地址
通过函数指针去调用指向的函数,有如下两种方案:
p为函数的指针。
(1) (*p)(实参列表)
(2) p(实参列表)
int *p=abc//函数名 p(a,b);//调用函数
二级指针 与 多级指针
int a,b;
可以定义一个指针变量p1,来保存变量a的地址:
int *p1=&a; b=*p1=*&a=a;//通过指针p1访问a变量
可以定义一个指针变量p2,来保存变量p1的地址:
int *p2=&p1 int b=**p2=*p1=a//通过指针p2访问a变量
p2保存的是一个一级指针p1的地址,所以说,
p2指向一个一级指针,p2就是一个二级指针
可以定义一个指针变量p3,来保存变量p2的地址:
int *p3=&p2; int b=***p3=**p2=*p1=a;
p3保存的是一个二级指针p2的地址,所以说,
p3指向一个二级指针,p3就是一个三级指针
到此这篇关于c语言简析指针用途的文章就介绍到这了,更多相关c语言指针内容请搜索<计算机技术网(www.ctvol.com)!!>以前的文章或继续浏览下面的相关文章希望大家以后多多支持<计算机技术网(www.ctvol.com)!!>!
需要了解更多c/c++开发分享C语言简析指针用途,都可以关注C/C++技术分享栏目—计算机技术网(www.ctvol.com)!
本文来自网络收集,不代表计算机技术网立场,如涉及侵权请联系管理员删除。
ctvol管理联系方式QQ:251552304
本文章地址:https://www.ctvol.com/c-cdevelopment/1119951.html