C语言指针最详尽的讲解
指针对于C来说太重要。然而,想要全面理解指针,除了要对C语言有熟练的掌握外,还要有计算机硬件以及操作系统等方方面面的基本知识。所以本文尽可能的通过一篇文章完全讲解指针。
为什么需要指针?
指针解决了一些编程中基本的问题。
第一,指针的使用使得不同区域的代码可以轻易的共享内存数据。当然小伙伴们也可以通过数据的复制达到相同的效果,但是这样往往效率不太好。
因为诸如结构体等大型数据,占用的字节数多,复制很消耗性能。
但使用指针就可以很好的避免这个问题,因为任何类型的指针占用的字节数都是一样的(根据平台不同,有4字节或者8字节或者其他可能)。
第二,指针使得一些复杂的链接性的数据结构的构建成为可能,比如链表,链式二叉树等等。
第三,有些操作必须使用指针。如操作申请的堆内存。
还有:C语言中的一切函数调用中,值传递都是“按值传递”的。
如果我们要在函数中修改被传递过来的对象,就必须通过这个对象的指针来完成。
指针是什么?
我们知道:C语言中的数组是指一类类型,数组具体区分为 int 类型数组,double类型数组,char数组 等等。
同样指针这个概念也泛指一类数据类型,int指针类型,double指针类型,char指针类型等等。
通常,我们用int类型保存一些整型的数据,如 int num = 97 , 我们也会用char来存储字符:char ch = 'a'。
image
弄清这个问题我们需要从操作系统的角度去认知内存。
电脑维修师傅眼中的内存是这样的:内存在物理上是由一组DRAM芯片组成的。
image
而作为一个程序员,我们不需要了解内存的物理结构,操作系统将RAM等硬件和软件结合起来,给程序员提供的一种对内存使用的抽象。
这种抽象机制使得程序使用的是虚拟存储器,而不是直接操作和使用真实存在的物理存储器。
image
在程序员眼中的内存应该是下面这样的。
image
也就是说,内存是一个很大的,线性的字节数组(平坦寻址)。每一个字节都是固定的大小,由8个二进制位组成。
最关键的是,每一个字节都有一个唯一的编号,编号从0开始,一直到最后一个字节。
由于内存中的每一个字节都有一个唯一的编号。
指针就是这样形成的。
下面用代码说明
image
指针的值实质是内存单元(即字节)的编号,所以指针单独从数值上看,也是整数,他们一般用16进制表示。
这就是为什么xp这种32位系统最大支持4GB内存的原因了。
我们可以大致画出变量ch和num在内存模型中的存储。(假设 char占1个字节,int占4字节)
image
变量和内存
为了简单起见,这里就用上面例子中的 int num = 97 这个局部变量来分析变量在内存中的存储模型。
image
1、内存的数据
内存的数据就是变量的值对应的二进制,一切都是二进制。
2、内存数据的类型
内存的数据类型决定了这个数据占用的字节数,以及计算机将如何解释这些字节。
num的类型是int,因此将被解释为 一个整数。
3、内存数据的名称
而且在C语言中,并不是所有的内存数据都有名称,例如使用malloc申请的堆内存就没有。
5、内存数据的生命周期
num是main函数中的局部变量,因此当main函数被启动时,它被分配于栈内存上,当main执行结束时,消亡。
如果一个数据一直占用着他的内存,那么我们就说他是“活着的”,如果他占用的内存被回收了,则这个数据就“消亡了”。
C语言中的程序数据会按照他们定义的位置,数据的种类,修饰的关键字等因素,决定他们的生命周期特性。
实质上我们程序使用的内存会被逻辑上划分为:栈区,堆区,静态数据区,方法区。
不同的区域的数据有不同的生命周期。
无论以后计算机硬件如何发展,内存容量都是有限的,因此清楚理解程序中每一个程序数据的生命周期是非常重要的。
指针变量和指向关系
用来保存指针的变量,就是指针变量。
image
定义指针变量
C语言中,定义变量时,在变量名前写一个 * 星号,这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。
引申:C语言中,定义变量时,在定义的最前面写上typedef ,那么这个变量名就成了一种类型,即这个类型的同义词。
我们需要一个数据的指针变量干什么?
当然使用通过它来操作(读/写)它指向的数据啦。
解指针的实质是:从指针指向的内存块中取出这个内存数据。
指针之间的赋值
指针之间的赋值是一种浅拷贝,是在多个编程单元之间共享内存数据的高效的方法。
image
空指针
指向空,或者说不指向任何东西。
在C语言中,我们让指针变量赋值为NULL表示一个空指针,而C语言中,NULL实质是 ((void*)0) , 在C++中,NULL实质是0。
下面代码摘自 stdlib.h
坏指针
不能对他们做解指针操作,否则程序会出现运行时错误,导致程序意外终止。
坏指针是造成C语言Bug的最频繁的原因之一。
指针的2个重要属性
指针也是一种数据,指针变量也是一种变量,因此指针 这种数据也符合前面变量和内存主题中的特性。
这里要强调2个属性:指针的类型,指针的值。
指针的类型:指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。
一般指针变量的类型要和它指向的数据的类型匹配。
void*类型指针
如果想要完整的提取指向的数据,程序员就必须对这个指针做出正确的类型转换,然后再解指针。
因为,编译器不允许直接对void*类型的指针做解指针操作。
结构体和指针
结构体指针有特殊的语法:-> 符号
如果p是一个结构体指针,则可以使用 p ->【成员】 的方法访问结构体的成员
数组和指针
<pre class="ql-align-justify">
int main(void)
{
int arr[3] = {1,2,3};
intp_first = arr;
printf("%d
",p_first); //1
return 0;
}
</pre>
2、指向数组元素的指针 支持 递增 递减 运算。
(实质上所有指针都支持递增递减 运算 ,但只有在数组中使用才是有意义的)
<pre class="ql-align-justify">
int main(void)
{
int arr[3] = {1,2,3};
intp = arr;
for(;p!=arr+3;p++){
printf("%d
",p);
}
return 0;
}
</pre>
3、p= p+1 意思是,让p指向原来指向的内存块的下一个相邻的相同类型的内存块。
同一个数组中,元素的指针之间可以做减法运算,此时,指针之差等于下标之差。
4、p[n] == *(p+n)
p[n][m] == *( *(p+n)+ m )
5、当对数组名使用sizeof时,返回的是整个数组占用的内存字节数。当把数组名赋值给一个指针后,再对指针使用sizeof运算符,返回的是指针的大小。
这就是为什么将一个数组传递给一个函数时,需要另外用一个参数传递数组元素个数的原因了。
<pre class="ql-align-justify">
int main(void)
{
int arr[3] = {1,2,3};
int*p = arr;
printf("sizeof(arr)=%d
",sizeof(arr)); //sizeof(arr)=12
printf("sizeof(p)=%d
",sizeof(p)); //sizeof(p)=4
return 0;
}
</pre>
函数和指针
函数的参数和指针
C语言中,实参传递给形参,是按值传递的,也就是说,函数中的形参是实参的拷贝份,形参和实参只是在值上面一样,而不是同一个内存数据对象。
这就意味着:这种数据传递是单向的,即从调用者传递给被调函数,而被调函数无法修改传递的参数达到回传的效果。
<pre class="ql-align-justify">
void change(int a)
{
a++; //在函数中改变的只是这个函数的局部变量a,而随着函数执行结束,a被销毁。age还是原来的age,纹丝不动。
}
int main(void)
{
int age = 19;
change(age);
printf("age = %d
",age); // age = 19
return 0;
}
</pre>
有时候我们可以使用函数的返回值来回传数据,在简单的情况下是可以的。
但是如果返回值有其它用途(例如返回函数的执行状态量),或者要回传的数据不止一个,返回值就解决不了了。
传递变量的指针可以轻松解决上述问题。
再来一个老生常谈的,用函数交换2个变量的值的例子:
<pre class="ql-align-justify">
include<stdio.h>
void swap_bad(int a,int b);
void swap_ok(intpa,intpb);
int main()
{
int a = 5;
int b = 3;
swap_bad(a,b); //Can`t swap;
swap_ok(&a,&b); //OK
return 0;
}
//错误的写法
void swap_bad(int a,int b)
{
int t;
t=a;
a=b;
b=t;
}
//正确的写法:通过指针
void swap_ok(intpa,intpb)
{
int t;
t=*pa;
pa=pb;
*pb=t;
}
</pre>
image
image
有的时候,我们通过指针传递数据给函数不是为了在函数中改变他指向的对象。
相反,我们防止这个目标数据被改变。传递指针只是为了避免拷贝大型数据。
考虑一个结构体类型Student。我们通过show函数输出Student变量的数据。
<pre class="ql-align-justify">
typedef struct
{
char name[31];
int age;
float score;
}Student;
//打印Student变量信息
void show(const Student * ps)
{
printf("name:%s , age:%d , score:%.2f
",ps->name,ps->age,ps->score);
}
</pre>
我们只是在show函数中取读Student变量的信息,而不会去修改它,为了防止意外修改,我们使用了常量指针去约束。
另外我们为什么要使用指针而不是直接传递Student变量呢?
从定义的结构看出,Student变量的大小至少是39个字节,那么通过函数直接传递变量,实参赋值数据给形参需要拷贝至少39个字节的数据,极不高效。
而传递变量的指针却快很多,因为在同一个平台下,无论什么类型的指针大小都是固定的:X86指针4字节,X64指针8字节,远远比一个Student结构体变量小。
函数的指针
每一个函数本身也是一种程序数据,一个函数包含了多条执行语句,它被编译后,实质上是多条机器指令的合集。
在程序载入到内存后,函数的机器指令存放在一个特定的逻辑区域:代码区。
既然是存放在内存中,那么函数也是有自己的指针的。
C语言中,函数名作为右值时,就是这个函数的指针。
<pre class="ql-align-justify">
void echo(const char msg)
{
printf("%s",msg);
}
int main(void)
{
void(p)(const char*) = echo; //函数指针变量指向echo这个函数
p("Hello "); //通过函数的指针p调用函数,等价于echo("Hello ")
echo("World
");
return 0;
}
</pre>
const和指针
const到底修饰谁?谁才是不变的?
如果const 后面是一个类型,则跳过最近的原子类型,修饰后面的数据。
(原子类型是不可再分割的类型,如int, short , char,以及typedef包装后的类型)
如果const后面就是一个数据,则直接修饰这个数据。
int main()
{
int a = 1;
int const p1 = &a; //const后面是p1,实质是数据a,则修饰*p1,通过p1不能修改a的值
const intp2 = &a; //const后面是int类型,则跳过int ,修饰p2, 效果同上
int* const p3 = NULL; //const后面是数据p3。也就是指针p3本身是const .
const int* const p4 = &a; // 通过p4不能改变a 的值,同时p4本身也是 const
int const* const p5 = &a; //效果同上
return 0;
}
typedef int* pint_t; //将 int* 类型 包装为 pint_t,则pint_t 现在是一个完整的原子类型
int main()
{
int a = 1;
const pint_t p1 = &a; //同样,const跳过类型pint_t,修饰p1,指针p1本身是const
pint_t const p2 = &a; //const 直接修饰p,同上
return 0;
}
深拷贝和浅拷贝
如果2个程序单元(例如2个函数)是通过拷贝他们所共享的数据的指针来工作的,这就是浅拷贝,因为真正要访问的数据并没有被拷贝。
如果被访问的数据被拷贝了,在每个单元中都有自己的一份,对目标数据的操作相互不受影响,则叫做深拷贝。
image
附加知识
指针和引用这个2个名词的区别。他们本质上来说是同样的东西。
指针常用在C语言中,而引用,则用于诸如Java,C#等 在语言层面封装了对指针的直接操作的编程语言中。
大端模式和小端模式
采用大端方式进行数据存放符合人类的正常思维,而采用小端方式进行数据存放利于计算机处理。
有些机器同时支持大端和小端模式,通过配置来设定实际的端模式。
short a = 1;
如下图:
image
‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧ END ‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧‧