C语言指针详解

时间 2019-11-21

标签 c语言指针详解繁體版

原文原文链接

前言

这不是我第一次写关于C指针的文章了，只是由于指针对于C来讲过重要，并且随着本身编程经历越多，对指针的理解越多，所以有了本文。然而，想要全面理解指针，除了要对C语言有熟练的掌握外，还要有计算机硬件以及操做系统等方方面面的基本知识。因此我想经过一篇文章来尽量的讲解指针，以对得起这个文章的标题吧。程序员

为何须要指针?

指针解决了一些编程中基本的问题。编程

第一，指针的使用使得不一样区域的代码能够轻易的共享内存数据。固然你也能够经过数据的复制达到相同的效果，可是这样每每效率不太好，由于诸如结构体等大型数据，占用的字节数多，复制很消耗性能。但使用指针就能够很好的避免这个问题，由于任何类型的指针占用的字节数都是同样的（根据平台不一样，有4字节或者8字节或者其余可能）。

第二，指针使得一些复杂的连接性的数据结构的构建成为可能，好比链表，链式二叉树等等。

第三，有些操做必须使用指针。如操做申请的堆内存。还有：C语言中的一切函数调用中，值传递都是“按值传递(pass by value)”的，若是咱们要在函数中修改被传递过来的对象，就必须经过这个对象的指针来完成。

指针是什么？

咱们指知道：C语言中的数组是指一类类型，数组具体区分为 int 类型数组，double类型数组,char数组等等。一样指针这个概念也泛指一类数据类型，int指针类型，double指针类型，char指针类型等等。

一般，咱们用int类型保存一些整型的数据，如 int num = 97 ，咱们也会用char来存储字符： char ch = 'a'。

咱们也必须知道：任何程序数据载入内存后，在内存都有他们的地址，这就是指针。而为了保存一个数据在内存中的地址，咱们就须要指针变量。

所以： 指针是程序数据在内存中的地址，而指针变量是用来保存这些地址的变量。

为何程序中的数据会有本身的地址？

弄清这个问题咱们须要从操做系统的角度去认知内存。

电脑维修师傅眼中的内存是这样的：内存在物理上是由一组DRAM芯片组成的。

而做为一个程序员，咱们不须要了解内存的物理结构，操做系统将DRAM等硬件和软件结合起来，给程序员提供的一种对物理内存使用的抽象。这种抽象机制使得程序使用的是虚拟存储器,而不是直接操做物理存储器。全部的虚拟地址造成的集合就是虚拟地址空间。数组

在程序员眼中的内存应该是下面这样的。（假设使用的是32位系统平台，虚拟存储空间为4GB）数据结构

也就是说，虚拟存储器是一个很大的，线性的字节数组（平坦寻址）。每个字节都是固定的大小，由8个二进制位组成。最关键的是，每个字节都有一个惟一的编号,编号从0开始，一直到最后一个字节。如上图中，这是一个4GB的虚拟存储器的模型，它一共有4x1024x1024x1024 个字节，那么它的虚拟地址范围就是 0 ~ 4x1024x1024x1024-1 。编程语言

因为内存中的每个字节都有一个惟一的编号，所以，在程序中使用的变量，常量，甚至数函数等数据，当他们被载入到内存中后，都有本身惟一的一个编号，这个编号就是这个数据的地址。指针就是这样造成的。函数

下面用代码说明性能

#include <stdio.h>

int main(void)
{
    char ch = 'a';
    int  num = 97;
    printf("ch 的地址:%p\n",&ch);   //ch 的地址:0028FF47
    printf("num的地址:%p\n",&num);  //num的地址:0028FF40
    return 0;
}

指针的值实质是内存单元（即字节）的编号，因此指针单独从数值上看，也是整数，他们通常用16进制表示。指针的值（虚拟地址值）使用一个机器字的大小来存储,也就是说,对于一个机器字为w位的电脑而言,它的虚拟地址空间是0~2 ^w － 1 ,程序最多能访问2 ^w个字节。这就是为何xp这种32位系统最大支持4GB内存的缘由了。

咱们能够大体画出变量ch和num在内存模型中的存储。（假设 char占1个字节，int占4字节）

变量和内存

为了简单起见，这里就用上面例子中的 int num = 97 这个局部变量来分析变量在内存中的存储模型。测试

已知：num的类型是int，占用了4个字节的内存空间，其值是97，地址是0028FF40。咱们从如下几个方面去分析。

一、内存的数据

内存的数据就是变量的值对应的二进制，一切都是二进制。97的二进制是 : 00000000 00000000 00000000 0110000 , 但使用的 小端模式存储时，低位数据存放在低地址，因此图中画的时候是倒过来的。

二、内存数据的类型

内存的数据类型决定了这个数据占用的字节数，以及计算机将如何解释这些字节。num的类型是int，所以将被解释为一个整数。

三、内存数据的名称

内存的名称就是变量名。实质上，内存数据都是以地址来标识的，根本没有内存的名称这个说法，这只是高级语言提供的抽象机制，方便咱们操做内存数据。并且在C语言中，并非全部的内存数据都有名称，例如使用malloc申请的堆内存就没有。

四、内存数据的地址

若是一个类型占用的字节数大于1，则其变量的地址就是地址值最小的那个字节的地址。所以num的地址是 0028FF40。内存的地址用于标识这个内存块。

五、内存数据的生命周期

num是main函数中的局部变量，所以当main函数被启动时，它被分配于栈内存上，当main执行结束时，消亡。

若是一个数据一直占用着他的内存，那么咱们就说他是“活着的”，若是他占用的内存被回收了，则这个数据就“消亡了”。C语言中的程序数据会按照他们定义的位置，数据的种类，修饰的关键字等因素，决定他们的生命周期特性。实质上咱们程序使用的内存会被逻辑上划分为：栈区，堆区，静态数据区，方法区。不一样的区域的数据有不一样的生命周期。

不管之后计算机硬件如何发展，内存容量都是有限的，所以清楚理解程序中每个程序数据的生命周期是很是重要的。

我会在之后的文章中再对C语言的内存管理作出介绍，敬请期待。

指针变量和指向关系

用来保存指针的变量，就是指针变量。若是指针变量p1保存了变量 num的地址，则就说：p1指向了变量num，也能够说p1指向了num所在的内存块，这种指向关系，在图中通常用箭头表示。spa

上图中，指针变量p1指向了num所在的内存块，即从地址0028FF40开始的4个byte 的内存块。操作系统

定义指针变量

C语言中，定义变量时，在变量名前写一个 * 星号，这个变量就变成了对应变量类型的指针变量。必要时要加( ) 来避免优先级的问题。

引伸：C语言中，定义变量时，在定义的最前面写上typedef ，那么这个变量名就成了一种类型，即这个类型的同义词。

int a ; //int类型变量 a
int *a ; //int* 变量a
int arr[3]; //arr是包含3个int元素的数组
int (* arr )[3]; //arr是一个指向包含3个int元素的数组的指针变量


//-----------------各类类型的指针------------------------------

int* p_int; //指向int类型变量的指针 

double* p_double; //指向idouble类型变量的指针 

struct Student *p_struct; //结构体类型的指针

int(*p_func)(int,int); //指向返回类型为int，有2个int形参的函数的指针 

int(*p_arr)[3]; //指向含有3个int元素的数组的指针 

int** p_pointer; //指向 一个整形变量指针的指针

取地址

既然有了指针变量，那就得让他保存其它变量的地址，使用& 运算符取得一个变量的地址。

int add(int a , int b)
{
    return a + b;
}

int main(void)
{
    int num = 97;
    float score = 10.00F;
    int arr[3] = {1,2,3};

    //-----------------------

    int* p_num = &num;
    float* p_score = &score;
    int (*p_arr)[3] = &arr;           
    int (*fp_add)(int ,int )  = add;  //p_add是指向函数add的函数指针
    return 0;
}

特殊的状况，他们并不必定须要使用&取地址：

数组名的值就是这个数组的第一个元素的地址。
函数名的值就是这个函数的地址。
字符串字面值常量做为右值时，就是这个字符串对应的字符数组的名称,也就是这个字符串在内存中的地址。

int add(int a , int b){
    return a + b;
}
int main(void)
{
    int arr[3] = {1,2,3};
    //-----------------------
    int* p_first = arr;
    int (*fp_add)(int ,int )  =  add;
    const char* msg = "Hello world";
    return 0;
}

解地址

咱们须要一个数据的指针变量干什么？固然使用经过它来操做（读/写）它指向的数据啦。对一个指针解地址，就能够取到这个内存数据，解地址的写法，就是在指针的前面加一个*号。

解指针的实质是：从指针指向的内存块中取出这个内存数据。

int main(void)
{
    int age = 19;
    int*p_age = &age;
    *p_age  = 20;  //经过指针修改指向的内存数据

    printf("age = %d\n",*p_age);   //经过指针读取指向的内存数据
    printf("age = %d\n",age);

    return 0;
}

指针之间的赋值

指针赋值和int变量赋值同样，就是将地址的值拷贝给另一个。指针之间的赋值是一种浅拷贝，是在多个编程单元之间共享内存数据的高效的方法。

int* p1  = & num;
int* p3 = p1;

//经过指针 p1 、 p3 均可以对内存数据 num 进行读写，若是2个函数分别使用了p1 和p3，那么这2个函数就共享了数据num。

空指针

指向空，或者说不指向任何东西。在C语言中，咱们让指针变量赋值为NULL表示一个空指针，而C语言中，NULL实质是 ((void*)0) ，在C++中，NULL实质是0。

换种说法：任何程序数据都不会存储在地址为0的内存块中，它是被操做系统预留的内存块。

下面代码摘自 stddef.h

#ifdef __cplusplus
     #define NULL    0
#else    
     #define NULL    ((void *)0)
#endif

坏指针

指针变量的值是NULL，或者未知的地址值，或者是当前应用程序不可访问的地址值，这样的指针就是坏指针，不能对他们作解指针操做，不然程序会出现运行时错误，致使程序意外终止。

任何一个指针变量在作解地址操做前，都必须保证它指向的是有效的，可用的内存块，不然就会出错。坏指针是形成C语言Bug的最频繁的缘由之一。

下面的代码就是错误的示例。

void opp()
{
     int*p = NULL;
     *p = 10;      //Oops! 不能对NULL解地址
}

void foo()
{
     int*p;
     *p = 10;      //Oops! 不能对一个未知的地址解地址
}

void bar()
{
     int*p = (int*)1000; 
     *p =10;      //Oops!   不能对一个可能不属于本程序的内存的地址的指针解地址
}

指针的2个重要属性

指针也是一种数据，指针变量也是一种变量，所以指针这种数据也符合前面变量和内存主题中的特性。这里我只想强调2个属性：指针的类型，指针的值。

int main(void)
{
    int num = 97;
    int *p1  = &num;
    char* p2 = (char*)(&num);

    printf("%d\n",*p1);    //输出  97
    putchar(*p2);          //输出  a
    return 0;
}

指针的值：很好理解，如上面的num 变量，其地址的值就是0028FF40 ，所以 p1的值就是0028FF40。数据的地址用于在内存中定位和标识这个数据，由于任何2个内存不重叠的不一样数据的地址都是不一样的。

指针的类型：指针的类型决定了这个指针指向的内存的字节数并如何解释这些字节信息。通常指针变量的类型要和它指向的数据的类型匹配。

因为num的地址是0028FF40，所以p1 和 p2的值都是0028FF40

*p1 : 将从地址0028FF40 开始解析，由于p1是int类型指针，int占4字节，所以向后连续取4个字节，并将这4个字节的二进制数据解析为一个整数 97。

*p2 : 将从地址0028FF40 开始解析，由于p2是char类型指针，char占1字节，所以向后连续取1个字节，并将这1个字节的二进制数据解析为一个字符，即'a'。

一样的地址，由于指针的类型不一样，对它指向的内存的解释就不一样，获得的就是不一样的数据。

void*类型指针

因为void是空类型，所以void*类型的指针只保存了指针的值，而丢失了类型信息，咱们不知道他指向的数据是什么类型的，只指定这个数据在内存中的起始地址，若是想要完整的提取指向的数据，程序员就必须对这个指针作出正确的类型转换，而后再解指针。由于，编译器不容许直接对void*类型的指针作解指针操做。

结构体和指针

结构体指针有特殊的语法： -> 符号

若是p是一个结构体指针，则可使用 p ->【成员】的方法访问结构体的成员。p->member 等价于 (*p).member。

typedef struct
{
    char name[31];
    int age;
    float score;
}Student;

int main(void)
{
    Student stu = {"Bob" , 19, 98.0};
    Student*ps = &stu;

    ps->age = 20;
    ps->score = 99.0;
    printf("name:%s age:%d\n",ps->name,ps->age);
    return 0;
}

数组和指针

一、数组名做为右值的时候，就是第一个元素的地址。

int main(void)
{
    int arr[3] = {1,2,3};
 
    int*p_first = arr;
    printf("%d\n",*p_first);  //1
    return 0;
}

二、指向数组元素的指针支持递增递减运算。（实质上全部指针都支持递增递减运算，但只有在数组中使用才是有意义的）

int main(void)
{
    int arr[3] = {1,2,3};
 
    int*p = arr;
    for(;p!=arr+3;p++){
        printf("%d\n",*p); 
    }
    return 0;
}

三、p= p+1 意思是，让p指向原来指向的内存块的下一个相邻的相同类型的内存块。

同一个数组中，元素的指针之间能够作减法运算，此时，指针之差等于下标之差。

四、p[n] == *(p+n)

p[n][m] == *( *(p+n)+ m )

五、当对数组名使用sizeof时，返回的是整个数组占用的内存字节数。当把数组名赋值给一个指针后，再对指针使用sizeof运算符，返回的是指针的大小。

这就是为何我么将一个数组传递给一个函数时，须要另外用一个参数传递数组元素个数的缘由了。

int main(void)
{
    int arr[3] = {1,2,3};
 
    int*p = arr;
    printf("sizeof(arr)=%d\n",sizeof(arr));  //sizeof(arr)=12
    printf("sizeof(p)=%d\n",sizeof(p));   //sizeof(p)=4
 
    return 0;
}

函数和指针

函数的参数和指针

C语言中，实参传递给形参，是按值传递的，也就是说，函数中的形参是实参的拷贝份，形参和实参只是在值上面同样，而不是同一个内存数据对象。这就意味着：这种数据传递是单向的，即从调用者传递给被调函数，而被调函数没法修改传递的参数达到回传的效果。

void change(int a)
{
    a++;      //在函数中改变的只是这个函数的局部变量a，而随着函数执行结束，a被销毁。age仍是原来的age，纹丝不动。
}
int main(void)
{
    int age = 19;
    change(age);
    printf("age = %d\n",age);   // age = 19
    return 0;
}

有时候咱们可使用函数的返回值来回传数据，在简单的状况下是能够的，可是若是返回值有其它用途（例如返回函数的执行状态量），或者要回传的数据不止一个，返回值就解决不了了。

传递变量的指针能够轻松解决上述问题。

void change(int* pa)
{
    (*pa)++;   //由于传递的是age的地址，所以pa指向内存数据age。当在函数中对指针pa解地址时，
               //会直接去内存中找到age这个数据，而后把它增1。
}
int main(void)
{
    int age = 19;
    change(&age);
    printf("age = %d\n",age);   // age = 20
    return 0;
}

再来一个老生常谈的，用函数交换2个变量的值的例子：

#include<stdio.h>
void swap_bad(int a,int b);
void swap_ok(int*pa,int*pb);

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(int*pa,int*pb)
{
    int t;
    t=*pa;
    *pa=*pb;
    *pb=t;
}

有的时候，咱们经过指针传递数据给函数不是为了在函数中改变他指向的对象，相反，咱们防止这个目标数据被改变。传递指针只是为了不拷贝大型数据。

考虑一个结构体类型Student。咱们经过show函数输出Student变量的数据。

typedef struct
{
    char name[31];
    int age;
    float score;
}Student;


//打印Student变量信息
void show(const Student * ps)
{
    printf("name:%s , age:%d , score:%.2f\n",ps->name,ps->age,ps->score);   
}

咱们只是在show函数中取读Student变量的信息，而不会去修改它，为了防止意外修改，咱们使用了常量指针去约束。另外咱们为何要使用指针而不是直接传递Student变量呢？

从定义的结构看出，Student变量的大小至少是39个字节，那么经过函数直接传递变量，实参赋值数据给形参须要拷贝至少39个字节的数据，极不高效。而传递变量的指针却快不少，由于在同一个平台下，不管什么类型的指针大小都是固定的：X86指针4字节，X64指针8字节，远远比一个Student结构体变量小。

函数的指针

每个函数自己也是一种程序数据，一个函数包含了多条执行语句，它被编译后，实质上是多条机器指令的合集。在程序载入到内存后，函数的机器指令存放在一个特定的逻辑区域：代码区。既然是存放在内存中，那么函数也是有本身的指针的。

C语言中，函数名做为右值时，就是这个函数的指针。

void echo(const char *msg)
{
    printf("%s",msg);
}
int main(void)
{
    void(*p)(const char*) = echo;   //函数指针变量指向echo这个函数

    p("Hello ");      //经过函数的指针p调用函数，等价于echo("Hello ")
    echo("World\n");
    return 0;
}

const 和指针

const到底修饰谁？谁才是不变的？

下面是我总结的经验，分享一下。

若是const 后面是一个类型，则跳过最近的原子类型，修饰后面的数据。（原子类型是不可再分割的类型，如int, short , char，以及typedef包装后的类型）

若是const后面就是一个数据，则直接修饰这个数据。

int main()
{
    int a = 1;
   
    int const *p1 = &a;        //const后面是*p1，实质是数据a，则修饰*p1，经过p1不能修改a的值
    const int*p2 =  &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个函数）是经过拷贝他们所共享的数据的指针来工做的，这就是浅拷贝，由于真正要访问的数据并无被拷贝。若是被访问的数据被拷贝了，在每一个单元中都有本身的一份，对目标数据的操做相互不受影响，则叫作深拷贝。

附加知识

指针和引用这个2个名词的区别。他们本质上来讲是一样的东西。指针经常使用在C语言中，而引用，则用于诸如Java，C#等在语言层面封装了对指针的直接操做的编程语言中。引用是编程语言提供给程序员的抽象机制，而指针是操做系统提供给软件开发模型的抽象机制。

大端模式和小端模式

1) Little-Endian就是低字节排放在内存的低地址端，高字节排放在内存的高地址端。我的PC经常使用，Intel X86处理器是小端模式。

2) B i g-Endian就是高字节排放在内存的低地址端，低字节排放在内存的高地址端。

采用大端方式进行数据存放符合人类的正常思惟，而采用小端方式进行数据存放利于计算机处理。有些机器同时支持大端和小端模式。

假如 short类型占用2个字节，且存储的地址为0x30。

short a = 1;

以下图：

 //测试机器使用的是否为小端模式。是，则返回true，不然返回false
//这个方法判别的依据就是：C语言中一个对象的地址就是这个对象占用的字节中，地址值最小的那个字节的地址。

bool isSmallIndain()
{
      unsigned int val = 'A';
      unsigned char* p = (unsigned char*)&val;  //C/C++：对于多字节数据，取地址是取的数据对象的第一个字节的地址，也就是数据的低地址
      
      return *p == 'A';
}