C语言的指针

指针是一种特殊的数据类型，它是一个可以存储数据变量地址的数据类型。运用指针编程是Ｃ语言最主要的风格之一。利用指针变量可以表示各种数据结构；能很方便地使用数组和字符串；并能象汇编语言一样处理内存地址，从而编出精练而高效的程序。

地址指针的概念

在计算机中，软件中的所有变量都是存储在内存中，一般在内存中一个字节就是一个存储单元。不同的数据类型占有的存储单元的个数不一样。如在32位系统中int型变量占有四个字节、char型变量占有一个字节等。那么在计算机中为了正确的访问每一个内存单元，因此每个内存单元都有特定的编号。根据一个内存单元的编号即可准确地找到某一个内存单元。内存单元的编号也叫做地址。

当每一个内存单元有一个特定的编号，那么我们根据内存单元的编号（地址）可以找到对应编号的内存单元，那么我们就将这个地址称为指针。严格来说，一个地址就是一个指针，指针是一个常量。但是一般我们在将指针变量也简称为指针。

指针变量是指存储内存单元的编号（指针或者地址）的一个指针类型的变量。这个变量可以存储某一个变量、数组、结构体和函数等一些类型的地址。由于数组、结构体和函数等一些复杂的类型在内存中是连续存储的，那么当我们找到他们的首地址，就可以根据首地址访问数组、结构体和函数的类容。

了解完指针变量之后，我们还需要了解和指针变量对应的一个概念，这个概念就是变量的指针，变量的指针就指的是变量存放的地址（内存编号）。

 

在我们使用指针的时候还需要理解内存单元的地址和内存单元的内容。内存单元的地址和内存单元的内容是两个不同的概念。内存单元的地址就是我们要使用的变量存储的位置。而内存单元的内容就是我们要获取的值，一般我们使用指针的目的就是获取内存单元中的内容。举例：内存单元的地址就相当于酒店的客房，我们可以根据门牌号进行入住和退房。而内存单元的内容住里面的人。

在Ｃ语言中，一种数据类型或数据结构往往都占有一组连续的内存单元。 用“地址”这个概念并不能很好地描述一种数据类型或数据结构，而“指针”虽然实际上也是一个地址，但它却是一个数据结构的首地址，它是“指向”一个数据结构，因而概念更为清楚，表示更为明确。 这也是引入“指针”概念的一个重要原因。

变量的指针（变量地址）和指向指针的变量（指针变量）

上面介绍过了，指针就是地址，那么变量的指针就指的是变量的地址。指向指针的变量就是指针变量，是一个存放指针（地址）的变量。

1 指针变量的定义

指针变量的定义和其他变量的定义一样，都需要指出是数据类型，这些数据类型包括基本的数据类型，也可以使用自定义的复杂类型。

定义格式如下：

数据类型 * 指针变量名；

1）数据类型指的是我们要定义的指针变量指向的地址中存储数据的类型

2）*表示这是一个指针变量，这是区别于其他变量的定义，如果在定义的时候不使用*号，则表示定义的是普通变量而不是指针变量。

3）指针变量名就是我们定义 的指针变量的名称，可以根据这个名称操做指针变量。

 

例如：

int * a;//这是定一个int型的指针变量，这个指针变量只能存储int型数据所在的地址。不能存储其他类型的数组所在地址。如果存储其他类型的数据地址，数据可能发生错乱导致软件死机。
int b;//这个没有在b之前增加*，则这个表示为一个普通的int型变量，这个b中存储的是一个int型数据，而不是地址。
int *p2;        /*p2是指向整型变量的指针变量*/
float *p3;      /*p3是指向浮点变量的指针变量*/
char *p4;       /*p4是指向字符变量的指针变量*/

 

注意：虽然指针变量中存储的是一个地址，但是在指针变量使用的时候会根据数据类型指向一个内存空间的首地址，而这个内存空间的大小是根据数据类型而定，如果指针变量指向的数据空间大小和数据类型大小不一样，那么在使用指针变量的过程中可能会对其他的内存空间修改，会造成系统的崩溃。因此指针变量只能存储跟指针变量相同的数据类型所在的地址，不能存储其他类型变量所在的地址。如p2这个指针变量只能存储 int型数据指向的地址，而不能存储float、char等其他类型所在的地址。          

2 指针变量的使用

指针变量的使用和普通变量的使用一样，都需先对变量赋值，赋值之后才能使用变量。如果指针变量不赋值的话操作指针会造成系统的崩溃。指针变量只能存储地址，因此给指针变量赋的值都是地址。指针变量在内存中占有四个字节大小。

1）指针两个运算符

1. 取出变量的地址使用&符号，这个符号就是取出变量的地址。如果是数组或者结构体直接将数组名可以赋值给指针变量，因为在数组中数组名就是数组的首地址。
2. 取出指针变量指向地址中的值使用*。这个符号是量指针变量指向地址中存储的具体数值取出来。

   例如：

int a; //定义一个普通的int型变量
int *b; //定义一个int型指针变量
b = &a;//这个语句是将a存放的地址取出来，赋值给指针变量。
a = *b;//这个语句是将指针变量指向的地址中的数组取出来赋值给a变量

2） 指针变量的初始化

    指针在定义的时候可以进行初始化赋值，初始化方法如下：

例如：

int a;
int *p = &a; //在定义的时候，可以给指针变量初始化赋值一个地址。

   也可以在定义的时候不进行初始化，在使用之前进行初始化

例如：

int a;
int *p;
p= &a; //在定义的时候，可以给指针变量初始化赋值一个地址。

  3）指针变量使用的注意事项

   （1）不允许把一个数赋予指针变量，故下面的赋值是错误的。

   例如：

int *p;
p = 1000;//这样赋值按照逻辑是可以讲通 但是这种赋值时讲一个野指针赋值给指针变量，这样会操做一些系统内存，因此可能会造成系统的崩溃，所以一般不会直接个指针变量赋值一个数值。

   （2) 被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的。

   例如：

int *p; int  a;
*p = &a;//这种赋值方式是不允许的，在p之前增加一个*代表的是取出p指针变量指向地址的值。如果p指针变量没有初始化，会报错。如果指针变量初始了，那么*p代表的是一个普通的int型数据，而&a代表的是一个地址也是一个常量。常量不能给常量赋值。

 （3）指针变量和一般变量一样,存放在它们之中的值是可以改变的,也就是说可以改变它们的指向。

  例如：

 int a；int b；
 int *p;
 p = &a;//p指针变量指向a变量所在的地址
 P = &b；//p指针指向b变量所在的地址

（4）通过指针访问它所指向的一个变量是以间接访问的形式进行的,所以比直接访问一个变量要费时间,而且不直观,因为通过指针要访问哪一个变量,取决于指针的值(即指向)。

由上图可见，p指针变量存储的是a变量的地址0xff00，而0xff00的地址中存储的是数值1000。而p指针是存储在地址0xff04中。

如使用 p = &a语句则是将0xff00的存储到p变量所对应的地址中。

使用 int c = *p语句则是将p指向的地址0xff00中存储的数据1000赋值给c变量。

3 指针变量作为函数参数

指针变量和普通的变量一样也可以作为函数的参数传递。普通变量的作为函数参数进行传递称为值传递，而指针变量作为参数传递称为地址传递。这两者传递使用效果不一样。使用值传递不会给变实参的值。但是使用地址传递的时候是可以给变实参的值的。

在函数参数中，如果使用数组或者指针传递参数，函数都会将参数当做指针进行处理。因此在使用数组和指针进行参数传递的时候，都需要传递指针或者数组的大小。当时用字符串数组进行参数传递的时候，可以不用传递字符数组的大小，字符数组的大小可以根据  sizeof函数和 \0 标志位进行获取。

例如： 地址传递

swap(int *p1,int *p2)
{
     int temp;
     temp=*p1;
     *p1=*p2;
     *p2=temp;
}
main()
{
    int a,b;
    int *pointer_1,*pointer_2;
    scanf("%d,%d",&a,&b);
    pointer_1=&a;pointer_2=&b;
    if(a<b) swap(pointer_1,pointer_2);
    printf("\n%d,%d\n",a,b);
}

如以上函数所示： swap函数就是一个以指针作为函数参数的函数。在调用swap函数的过程中将p1指向地址的变量和p2指向地址的变量互换。在main函数中输出a和b的结果。则a和b的值发生了互换。

例如：值传递

swap(int a,int b)
{
    int temp;
    temp=a;
    a=b;
    b=a;
}
main()
{
    int a,b;
    int *pointer_1,*pointer_2;
    scanf("%d,%d",&a,&b);
    pointer_1=a;pointer_2=b;
   if(a<b) swap(pointer_1,pointer_2);
    printf("\n%d,%d\n",a,b);
}

以上这个函数是使用值传递进行更换a和b的值，输出结果发现a和b的值并没有发生互换，那么为啥会出现这种情况。一下做一个简要的说明：

在使用值传递的时候，函数会将实参的值传递给形参，这里要特别说明一下，有些时候在调用的函数的时候实参和形参的是名称是一样的，但是这两变量是独立的之间没有关联。因此在值传递的时候，当实参把值传递给形参的时候就和调用的函数没有关系了。而在子函数中虽然对形参的a和b的数值进行替换。但是在函数运行结束之后，软件会自动释放形参的值。因此当主函数输出的时候，仍然输出的是没有改变的实参的值。

当时用地址传递的时候，我们将一个变量的地址以参数的形式传递过去，而在子函数中通过地址将地址中的值进行给变。当子函数运行结束之后所使用的变量释放了，但是内存中的地址是唯一的，因此当我们在main函数中输出a的值的时候，a变量所在地址中的值已经发生了改变。

 

4 指针变量作为函数返回值（指针型函数）

所谓函数类型是指函数返回值的类型。在Ｃ语言中允许一个函数的返回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。指针作为函数返回值和普通变量一样，只不过返回的是一个地址。程序员可根据返回的地址获取或者修改地址中的值。

定义指针型函数的一般形式为：    

类型说明符 *函数名(形参表)  
{  
     /*函数体*/
}  

其中函数名之前加了“*”号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。

如：   

int *ap(int x,int y)
{
    /*函数体*/
}

表示ap是一个返回指针值的指针型函数，它返回的指针指向一个整型变量。

    使用指针作为函数返回值需要注意一下事项：

（1）当函数返回的指针变量中存储的调用函数中定义的变量的地址，那么在调用函数结束之后，此地址中的值会被销毁。因此返回的指针中会有地址，但是此地址中的值无法获取到。

（2）当函数返回的指针变量中存储的是字符常量、其他常量、使用static修饰的静态变量、全局变量或者生命周期大于调用函数生命周期的变量地址的时候，返回的指针中可以获取到地址和地址中的值。

（3）返回值的指针类型必须和函数定义的指针类型一致，并且保证返回的地址中一定有值数组指针和指向数组的指针变量

5 指针变量的运算符

赋值运算：指针变量的赋值运算有以下几种形式。

指针变量初始化赋值，前面已作介绍。

1）把一个变量的地址赋予指向相同数据类型的指针变量。

例如：

int a,*pa;
pa=&a;    /*把整型变量a的地址赋予整型指针变量pa*/

2）把一个指针变量的值赋予指向相同类型变量的另一个指针变量。

如：   

int a,*pa=&a,*pb;
pb=pa;    /*把a的地址赋予指针变量pb*/

由于pa,pb均为指向整型变量的指针变量，因此可以相互赋值。

3）把数组的首地址赋予指向数组的指针变量。

例如：   

int a[5],*pa;
pa=a;

    (数组名表示数组的首地址，故可赋予指向数组的指针变量pa)

也可写为：

pa=&a[0];  /*数组第一个元素的地址也是整个数组的首地址，              也可赋予pa*/

  当然也可采取初始化赋值的方法：

 int a[5],*pa=a;

   4）把字符串的首地址赋予指向字符类型的指针变量。

例如：    

char *pc;
pc="C Language";

或用初始化赋值的方法写为：

char *pc="C Language";

这里应说明的是并不是把整个字符串装入指针变量，而是把存放该字符串的字符数组的首地址装入指针变量。在后面还将详细介绍。

5）把函数的入口地址赋予指向函数的指针变量。

例如：

int (*pf)();
pf=f;     /*f为函数名*/

6）加减算术运算

对于指向数组的指针变量，可以加上或减去一个整数n。设pa是指向数组a的指针变量，则pa+n,pa-n,pa++,++pa,pa--,--pa运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。

应该注意，数组指针变量向前或向后移动一个位置和地址加1或减1在概念上是不同的。因为数组可以有不同的类型，各种类型的数组元素所占的字节长度是不同的。如指针变量加1，即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。

例如： 

int a[5],*pa;
pa=a;      /*pa指向数组a，也是指向a[0]*/
pa=pa+2;   /*pa指向a[2]，即pa的值为&pa[2]*/

指针变量的加减运算只能对数组指针变量进行，对指向其它类型变量的指针变量作加减运算是毫无意义的。

两个指针变量之间的运算：只有指向同一数组的两个指针变量之间才能进行运算，否则运算毫无意义。

两指针变量相减：两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。例如pf1和pf2是指向同一浮点数组的两个指针变量，设pf1的值为2010H，pf2的值为2000H，而浮点数组每个元素占4个字节，所以pf1-pf2的结果为(2000H-2010H)/4=4，表示pf1和 pf2之间相差4个元素。两个指针变量不能进行加法运算。 例如，pf1+pf2是什么意思呢?毫无实际意义。

两指针变量进行关系运算：指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的关系。

例如：

pf1==pf2    表示pf1和pf2指向同一数组元素；
pf1>pf2     表示pf1处于高地址位置；
pf1<pf2     表示pf2处于低地址位置。

指针变量还可以与0比较。

设p为指针变量，则p==0表明p是空指针，它不指向任何变量；

p!=0表示p不是空指针。

空指针是由对指针变量赋予0值而得到的。

例如：

#define NULL 0
int *p=NULL;

对指针变量赋0值和不赋值是不同的。指针变量未赋值时，可以是任意值，是不能使用的。否则将造成意外错误。而指针变量赋0值后，则可以使用，只是它不指向具体的变量而已。

 

字符串的指针（字符串的地址）和指向字符串的针指变量（字符串指针）

1 字符串在内存中的存储形式和使用方式

在C语言中，字符串一般是以字符数组的形式存在，即使在定义的时候可以直接将一个字符串赋值给一个没有设置大小的字符数组中，但是在内存中字符串和字符数组的存储形式一样，只不过在在字符数组的最后一个元素存储的是字符串结束标志‘\0’。由于字符串结束标志的存在，因此字符数组在直接赋值字符串的时候可以不用设置字符数组的大小，可以通过’\0’来控制和计算字符数组的大小。

例如；

char str[] = “hello word”;//这个字符数组没有定义大小，但是可以使用，他等价于//char str[11] = {‘h’,’e’,’l’,’l’,’o’,’ ’,’w’,’o’,’r’,’d’,’\0’};

在内存中的存储形式为：

……	……
str所在位置，既字符串首地址str[0]	h
str[1]	e
str[2]	l
str[3]	l
str[4]	o
str[5]	空格
str[6]	w
str[7]	o
str[8]	r
str[9]	d
str 字符数组的最后一位，结束标志str[11]	\0

在C语言中字符串有两种使用方式：

1）使用一个字符数组来存储和访问字符串

例如：char str[] = “hello word”;

2）使用指针类访问和存储字符串

例如：char *str = “hello word”;

需要注意的是当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。

如果是以字符数组的方式使用字符串的话，直接可以通过首地址str进行使用，也可以通过字符数组下标的形式访问字符串中的每一个元素。

如果用字符串指针指向一个字符串。字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。

如：

     char c,*p=&c;//表示p是一个指向字符变量c的指针变量。

而：

    char *str = “hello word”;则表示str是一个指向字符串的指针变量。把字符串的首地址赋予str。

上例中，首先定义str是一个字符指针变量，然后把字符串的首地址赋予str(应写出整个字符串，以便编译系统把该串装入连续的一块内存单元)，并把首地址送入string。

程序中的：

     char *ps="C Language";

等效于：

    char *ps;

    ps="C Language";

对字符指针进行增加或者减少可以访问字符串中不同的元素，例如 char *str = “hello word”;

str 指向的是字符串的首地址h所在的地址，str+1则指向e字符所在的地址。因此通过字符指针可以是使用整个字符串也可以获取字符中的每一个元素。

2 使用字符串指针变量与字符数组的区别

    字符串指针变量就是指向字符串首地址的指针变量。而字符串的名称就是字符串的首地址，因此使用字符串指针和字符串名有一些类似之处。但是也有地方不同。例如用字符数组和字符指针变量都可实现字符串的存储和运算，但是使用字符串指针不能使用sizeof函数获取字符串的大小，但是使用字符串名称可以通过sizeof函数获取字符串的大小。

  因此在使用时应注意以下几个问题：

1)字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘\0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。

对字符串指针方式

     char *ps="C Language";

可以写为：

    char *ps;

    ps="C Language";

而对数组方式：

    static char st[]={"C Language"};

不能写为：

    char st[20];

    st={"C Language"};

而只能对字符数组的各元素逐个赋值。

从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。

前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。

因此，

    char *ps="C Langage";

或者

    char *ps;

    ps="C Language";

都是合法的。

 

数组指针（指向数组的指针变量）

指针作为一个可以存储变量地址的变量，不仅可以存储普通变量的的地址，也可以存储一些复杂数据结构和数组。而当指针变量指向一个数组地址的时，可以通过指针变量访问数组存储的地址对数组进行操作。简单点说数组指针就是一个指向数组地址的指针变量。

这个指针变量可以存储了数组中任意元素的地址（包括首地址或者其他地址）。

数组指针在定义的时候，指针类型必须和数组中元素的类型一样。如果不一样在使用的时候会出现错误。

1 数组在内存中的存储结构

在介绍数组的时候就简单介绍过数组在内存中的存储方式，下面就分别对一元数组和二元数组在内存中存储的方式做一个简单的介绍。

1）一元数组在内存中的存储结构

一元数组就是相同类型数据的一个集合，是连续存储在内存中的。而数组名就是这个数组在内存中的首地址。简单的就可以将数组的数组名看成一个指针变量了。

例：

int p[10] = {0,1,2,3,4,5,6,7,8,9};

这是定义的一个int型整形数组，数组中存储的数据为0~9.那他在内存中数如何存储。

假设一下是一系列的存储单元

内容	……	0	1	2	3	4	5	6	7	8	9	……
地址	……	P （0xff00）									（0xff28）

由以上图可以看出数组的首地址的编号为0xff00，也是数组下标为0 的元素所在位置。而在数组中数组的名称就是数组的首地址。因此数组的首地址我们可以直接使用数组名称也可以取0号下标所在的地址。

还有在数组中相邻元素之间的地址地址并不一定是连续，这是因为在数组定义的时候不同的数据类型占有大的内存大小不一样，如上图所示，定义的是一个int型的数组，由于int型数据在内存中占有四个字节，因此相邻元素的地址指向相差四个字节。

2）二元数组在内存中的存储结构

如果说一元数组是相同类型数据的集合的话，那么二元数组就是相同数据类型的一元数组的集合。为什么这么说？Ｃ语言允许把一个二维数组分解为多个一维数组来处理。因此我们可以将一个二元数组当做为几个一元数组来看待。

例：int a[5][3];//定义一个5行3列数二元数组，那么这5行3列的二元数组就可以拆分为5个含有3个元素的一元数组。

    a = {{1,2,3},{4,5,6},{7,8,9},{10,11,12},{13,14,15}};

对于这个数组而言我们一般看来的形式如下所示：

	1列	2列	3列
第一行（a）	1  （a） (a[0])  (a[0][0])	2        (a[0][3])	3        (a[0][2])
第二行	4     (a[1])     (a[1][0])	5        (a[1][1])	6         (a[1][1])
第三行	7     (a[2])     (a[2][0])	8        (a[2][1])	9         (a[2][2])
第四行	10   (a[3])     (a[3][0])	11      (a[3][1])	12       (a[3][2])
第五行	13   (a[4])      (a[4][0])	14      (a[4][1])	15       (a[4][1])

而二元数组在内存中的存储方式并非如此，而是一行一行的进行存储的。因此每一行都有一个起始地址。

……	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	……
……	这个是数组首地址也是第一行首地址			第二行首地址			第三行首地址			第四行首地址			第五行首地址			……

由上图可知二元数组的名称a首地址可以是数组名、第一行a[0的首地址、第一个元素a[0][0]的地址。二元是数组中的每一个元素是连续存储在内存中，而且是一行一行进程存储的。

2 数组指针引用数组元素

1）数组指针引用一元数组的元素

在使用指针变量指向数组地址的时候，如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素。

引入指针变量后，就可以用两种方法来访问数组元素了。

如果p的初值为&a[0],则：p+i和a+i就是a[i]的地址，或者说它们指向a数组的第i个元素。

*(p+i)或*(a+i)就是p+i或a+i所指向的数组元素，即a[i]。例如，*(p+5)或*(a+5)就是a[5]。指向数组的指针变量也可以带下标，如p[i]与*(p+i)等价。

根据以上叙述，引用一个数组元素可以用：

（1）下标法，即用a[i]形式访问数组元素。在前面介绍数组时都是采用这种方法。

（2）指针法，即采用*(a+i)或*(p+i)形式，用间接访问的方法来访问数组元素，其中a是数组名，p是指向数组的指针变量，其处值p=a。

几个注意的问题：

（1）指针变量可以实现本身的值的改变。如p++是合法的；而a++是错误的。因为a是数组名，它是数组的首地址，是常量。

（2）要注意指针变量的当前值。如果指针变量进行了运算 且指针变量发生了变化。那么刚开始的指针变量会指向别的地址而不是刚开始的值。

（3）虽然定义数组时指定它的个元素数确定的，但指针变量可以指到数组以后的内存单元，系统并不认为非法。因此在指针指向数组的时候一定要注意指针是否越界。

（4）*p++，由于++和*同优先级，结合方向自右而左，等价于*(p++)。

（5）*(p++)与*(++p)作用不同。若p的初值为a，则*(p++)等价a[0]，*(++p)等价a[1]。

（6）(*p)++表示p所指向的元素值加1。

（7）如果p当前指向a数组中的第i个元素，则*(p--)相当于a[i--]；*(++p)相当于a[++i]；*(--p)相当于a[--i]。

 

2）数组指针引用二元数组的元素

   前面介绍了二元数组可以拆分为几个一元数组，因此二元数组除了二元数组的首地址之外，分别还对应有每个一元数组的地址。

设有整型二维数组a[3][4]

它的定义为：

int a[3][4]={{0,1,2,3},{4,5,6,7},{8,9,10,11}}

a是二维数组名，a代表整个二维数组的首地址，也是二维数组0行的首地址，也会是二维数组中第一个元素的地址。a+1代表第一行的首地址，a[0]是第一个一维数组的数组名和首地址，由此可得出：a+i，a[i]，*(a+i)，&a[i][0]是等同的，他们是每一个一元数组的首地址。

由a[i]=*(a+i)得a[i]+j=*(a+i)+j。由于*(a+i)+j是二维数组a的i行j列元素的首地址，所以，该元素的值等于*(*(a+i)+j)。

 

3指向多维数组的指针变量

把二维数组a分解为一维数组a[0],a[1],a[2]之后，设p为指向二维数组的指针变量。可定义为：

          int (*p)[4]

它表示p是一个指针变量，它指向包含4个元素的一维数组。若指向第一个一维数组a[0]，其值等于a,a[0]，或&a[0][0]等。而p+i则指向一维数组a[i]。从前面的分析可得出*(p+i)+j是二维数组i行j 列的元素的地址，而*(*(p+i)+j)则是i行j列元素的值。

二维数组指针变量说明的一般形式为：

类型说明符  (*指针变量名)[长度];

其中“类型说明符”为所指数组的数据类型。“*”表示其后的变量是指针类型。“长度”表示二维数组分解为多个一维数组时，一维数组的长度，也就是二维数组的列数。应注意“(*指针变量名)”两边的括号不可少，如缺少括号则表示是指针数组(本章后面介绍)，意义就完全不同了。

 

使用指针和数组名称引用数组元素的区别

使用指针和数组名来引用数组元素在赋值和取值中没有太大差别，指示在获取数组大小的时候，我们使用sizeof通过数组名获取数组大小，但是无法通过指针变量获取数组大小。

 

指针数组

指针数组指的是一个数组的存储的元素类型为指针变量。 指针数组是一组有序的指针的集合。 指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

指针数组说明的一般形式为：

  类型说明符 *数组名[数组长度]

  其中类型说明符为指针值所指向的变量的类型。

例如：

int *pa[3]

表示pa是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。

指针数组和二维数组指针变量的区别。这两者虽然都可用来表示二维数组，但是其表示方法和意义是不同的。

二维数组指针变量是单个的变量，其一般形式中"(*指针变量名)"两边的括号不可少。而指针数组类型表示的是多个指针(一组有序指针)在一般形式中"*指针数组名"两边不能有括号。

例如：

    int (*p)[3];

表示一个指向二维数组的指针变量。该二维数组的列数为3或分解为一维数组的长度为3。

    int *p[3]

表示p是一个指针数组，有三个下标变量p[0]，p[1]，p[2]均为指针变量。

指针数组也常用来表示一组字符串，这时指针数组的每个元素被赋予一个字符串的首地址。指向字符串的指针数组的初始化更为简单。

例如:

 char *name[]={"Illagal day","Monday","Tuesday", 
                 "Wednesday", "Thursday", "Friday","Saturday","Sunday"};

 完成这个初始化赋值之后，name[0]即指向字符串"Illegal day"，name[1]指向"Monday"......。

指针数组也可以用作函数参数。

二级指针（指向指针的指针）

指针变量既然是一个变量，那么他应给也是存放在内存中，只要是存储在内存中，那必然有对应的地址。因此指针变量也是存储在内存中，对应着一个内存地址。因此我们可以将一个指针变量的地址赋值给另一个指针变量。而存储指针变量地址的指针变量称为指向指针的指针。简单来说就是一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。指向指针的指针变量又称为二级指针。

指向指针的指针变量的定义

char **p;

char 代表的是指向指针的指针变量的类型
** 两个**表示这定义的是一个指向指针的指针变量
p  为指向指针的变量名

1)指向指针的指针变量的使用

   例如：

int a = 100;//定义一个普通变量，普通变量中存储一个数字100
int  *p = &a; //定义一个指针变量指向变量a的地址
int **pp =&p；//定义一个指向指针的指针变量，并且指向指针p的地址。

 编写如下代码：

#include <stdio.h>
#include <stdlib.h>
int  main()
{
    int a = 100;
    int *p = &a;
    int **pp = &p;
    printf("%p\n",&a);
    printf("%p\n", p);
    printf("%p\n", &p);
    printf("%p\n", pp);
    printf("===================\n");
    printf("%d\n", a);
    printf("%d\n", *p);
    printf("%p\n", *pp);
    printf("%d\n", **pp);
    system("pause");
    return 0;
}

输出结果如下：

0113F95C
0113F95C
0113F950
0113F950
===================
100
100
0113F95C
100

根据结构可以看出    p的输出结果是0113F95C，他是变量a的地址，pp的输出结果为0113F950他是指针变量p的地址。由此可见指针变量指向的是变量的地址，而指向指针的变量指向的是指针的地址。

 *p的输出结果是100，*pp输出的结果是p的地址。**pp输出的结果是100.

由此可见在指向指针的指针变量前面多加一个*，则指向的内容会向前推进一级。

将**pp可以看成*（*pp），pp中存储的是指针指针变量的地址，因此*pp会取出指向指针的指针变量的内容，而指向指针的指针变量的内容为p的地址。因此*（*pp）等价于*（p）。

*（p）等价于*p等价于a变量的值。因此**pp等价于*p等价于a。

函数指针

1函数指针的定义

在Ｃ语言中，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的首地址。我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量称为“函数指针变量”。

函数指针变量定义的一般形式为：

类型说明符  (*指针变量名)();

其中“类型说明符”表示被指函数的返回值的类型。“(* 指针变量名)”表示“*”后面的变量是定义的指针变量。最后的空括号表示指针变量所指的是一个函数。

2函数指针的使用

调用函数的一般形式为：

  (*指针变量名) (实参表)

  使用函数指针变量还应注意以下两点：

1) 函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。

2)函数调用中"(*指针变量名)"的两边的括号不可少，其中的*不应该理解为求值运算，在此处它只是一种表示符号。

例如：

#include <stdio.h>
#include <stdlib.h>
void fun(int a);//定义需要调用的函数，如果函数的实现在main函数后面。则需要在main函数之前定义
main()
{
    int a = 10; //定义一个常量a，赋值为100
    void (*fun1)();//定义一个函数指针
    fun1 = fun;//将要调用的函数赋值给函数在指针，
    fun1(a); //通过函数指针调用函数
    system("pause");
}

void fun(int a)//函数的实现
{
    printf("%d\n", a);
}

输出结果为

10

 

三大指针

一、野指针

野指针指的是将一个未知内容的地址值赋值给一个指针变量。野指针的存在可能会导致软件出现读写的错误。

例：

int *p = 10000;//给一个int型指针变量赋值一个数值，这个数据可以认为是一个地址，但是这个地址中存储的数据我们不知道。这种就是野指针

二、空指针

空指针指的是给一个指针变量赋值一个为0的空间地址（NULL），操作空指针变量软件会出现报错，但是空指针可用于条件判断。

int *p = NULL;//这种赋值是可以的，可以用于判断，但是后续不能在对此指针变量不能操作。

三、万能指针

万能指针指的是使用void定义的指针变量，万能指针在使用的时候只需要使用强转将为自己想要的类型即可。

例：

void * p；
(int *)p= &a;//将万能指针变量强制转化为int * 类型的指针变量

const修饰指针

1 const修饰普通变量

const int a = 0；

const修饰普通变量，虽然不能直接给a 赋值，但是可以通过指针变量修改变量地址中的值

2 const修饰指针类型

const   int * p = &a；

使用const 修饰指针类型，则不能改变指针变量指向的内存地址中的值，但是可以修改指针变量指向的地址。

3 const修饰指针变量

int * const p = &a；

使用const修饰指针变量，这种修饰能改变指针变量指向地址中的值，但是不能改变指针指向的地址。

4 const修饰指针类型也修饰指针变量

const  int * const  p = &a；

const修饰指针类型，也修饰指针变量，不能改变指针指向地址的值也不能修改指针指向的地址