指针

来源：互联网发布：任务多软件下载编辑：程序博客网时间：2024/05/17 07:55

一、指针

1、指针的概念：用来保存地址的“变量”叫做指针，可以理解成指针是地址的一个别名。

例：定义一个整形指针

2、“指针的内容”，“指针所指向的内容”，“指针变量的地址”

（1）、指针的内容：

指针变量p里面存放的是a的地址，也就是0x0018ff44.

（2）、指针所指向的内容：

指针变量p里面存放的地址（0x18ff44）这块空间所对应的值，也就是10，我们通过*p(解引用）可以访问到这个值。即：*p作为右值时，*p==10，当*p作为左值时代表的就是a这块空间。

（3）、指针的地址：

指针p本身有一个地址，由编译器分配的我们不知道，注意：不要讲指针变量p本身的地址和p所保存的地址（0x0018ff44)相混淆。

3、"未初始化的指针"和"NULL指针"

例：定义两个指针变量p1和p2:

int *p1; //未初始化的指针

int *p2=NULL; //空指针

*p1=10;

*p2=10;

这样赋值显然是错误的，为什么呢？？？

试想一下，p1，p2是一个指针变量，所以p1,p2里面应该存放的应该是一个地址。而对于p1我们没有往里面放地址，这时p1是随机指向的。如果此时解引用*p1,访问到的是块随机的地址，再修改这个随机地址里面的值，假设这个随机空间里面的值非常重要，那你就再也找不回来了，所以通常定义一个指针就将他初始化为NULL。

对于p2：虽然我们将它初始化为NULL,但它指向的是一块空地址啊！！！向一块空地址里面放东西，根本是不可能的。

4、指针常量：

例：*（int *）200=10；

相信很多人对这个表达是都会产生疑惑，其实很好理解的，200是一个常数，我们将它强制转化为 int *（也就是将常数200转化成一个整形地址），再对这块地址进行*引用，就访问到一块空间，可以对这块空间进行赋值。

5、常量指针

例：int *p=&100;

让指针指向一个常量，一般用不到。

二、高级指针

1、二级指针概念：

什么是指针？？？存放地址的变量就叫做指针，所以二级指针就是存放一级指针地址的指针变量。

注意：跟一级指针一样，二级指针变量p2里面存放的是一级指针变量p1的地址，一级指针变量p1里面存放的是a的地址。要想访问一块地址里面的内容可以使用间接访问符“*”，所以：

*p2==&p1, *p2就是访问p2这块空间里面存放的地址所对应的内容。

**p2==10,因为*p2得到的结果是p1的地址，在对p1的地址进行解引用*p1就访问到了10.

例1：分析下面几种情况下能不能作为可修改的左值（可修改的左值必须代表一块空间）

int a=10;

int *cp=&a;

（1）*cp=20 //可以作为左值，当cp指向a时，*cp放到等号左边代表a这块空间，当*cp放到等号右边代表a这块空间的值。

（2）&a=20 //错误，&a不可以作为左值，因为他不能表示一块特定的空间，&a得到的结果是a的地址，但并不代表a这块空间，要想使用这块空间，必须进行*引用，*&a=20正确。&a可以作为右值，代表是a的地址这个数值。

（3）*cp+1 //不可以作为左值，因为*优先级高于+，所以*cp先结合，再加1相当于10+1，不代表一块空间。

（4）*(cp+1) //可以作为左值，cp+1先结合,指向a的下一块空间，再对这块空间进行*引用，放在等号左边就代表这块空间。

（5）++cp //不可以作为左值，因为++cp只是将cp里面的内容加一，并没有进行*引用

（6）cp++ //不可以作为左值

（7）*cp++ //可以作为左值，先对cp里面的地址进行*引用。再让cp=cp+1（也就是让cp指向a的下一块空间，因为++优先级高于*）

（8）++*cp //不可以作为左值，*cp代表cp所指向的内容，再让其加一，相当于10+1

注意：C中++cp和--cp都不能做左值，C++中++cp可以作为左值。

例2：const 修饰一级指针，修饰二级指针(const修饰的变量，还是一个变量，只不过只是可读的）

int const a=10;

int b=30;

1、a=20; //错误，const修饰a，所以不能改变a的值

2、int const *p; //const修饰的是*p，所以不能改变*p

p=&a; //正确

*p=20; //错误不能通过*p改变a的值

3、const int *p; //const修饰的是*p

p=&a; //正确

*p=20; //错误

4、int *const p=&a; //const修饰的是p

p=&b; //错误不能改变p

*p=20; //正确

5、int const * const p; //const修饰*p，也修饰p，所以*p,p都不能改变

p=&b; //错误

*p=20; //错误

注意：const修饰变量的原则是离谁近修饰谁。const int *p与int const *p完全一样。

2、指针和数组的关系，指针数组，数组指针，指针的运算

2.1、指针和数组的关系：

很多人都分不清指针和数组之间的关系，严格的来讲指针和数组之间没关系，指针是指针，数组是数组。只不过他们两个都可以通过“*”引用的方式和下标的方式来访问元素而已。

例1：

int a[5]={1,2,3,4,5};

int *p=a;

a[5]占20个字节的大小，而p只占4个字节的大小，其次p本身有自己的地址，只不过他里面存放的是数组首元素的地址。

要访问3则有两种方式：a[2]或者*(a+2).

其中*(a+2)就是*的形式访问的，因为a表示首元素的地址，加2表示向后偏移2个整形大小，找到3的地址，在通过*得到3.

在编译器中a[2]会被先解析成*（a+2）访问的。

例2：

所以必须保持定义和声明的一致性，指针就是指针，数组就是数组。

3、指针数组，数组指针

注意：[]的优先级高于*，指针数组是一个数组，只不过里面的元素全部都是指针。数组指针是一个指针，指向数组的指针，偏移的单位是整个数组。

例1：

int a[6]={1,2,3,4,5,6};

int (*p2)[6];

p2=a;

这是错误的，因为指针p2的类型是int [6],所以应该是p2=&a;

int (*p2)[3];

这样的话p2的类型是int [3]，所以p2=(int（*） [3])&a; 要强制转换成数组指针的类型。

注意：数组指针“所指向”的类型就是去掉指针变量之后所剩下的内容。

数组指针的类型就是去掉指针后剩下的内容。

例2：int （*p3)[5];

p3的类型是 int（*）[5];

p3所指向的类型是 int [5];

4、指针的运算：

1、指针相减得到的结果是两指针之间元素的个数，而不是字节数。

2、指针的运算

例1：

struct test

{

int name;

char *pcname;

short data;

char c[2];

}*p;

假设p的值是0x100000,结构体的大小是12；

则：

1、 p+0x1=0x10000c //p指向结构体则p+1表示的是p+sizeof（test)*1

2、(unsigned int)p+0x1=0x100001 //p已经被转化为一个无符号的数，加一就相当于两个数相加

3、(int *)p+0x1=0x100004 //p被转化为int *，所以p+1就表示p+sizeof(int *)*1

例2：假设当前机器小端存储

int a[4] = { 1, 2, 3, 4 };

int *p = (int *)(a + 1);

int *p1 = (int *)(&a + 1);

int *p2 = (int *)(( int)&a + 1);

printf( "*p=%d,*p1=%d,*p2=%d\n" , *p, p1[-1],*p2);

输出结果：*p=2,*p1=4,*p2=2000000

解析：p = (int *)(a + 1); a代表首元素地址，加1指向第二个元素，所以是2.

p1 = (int *)(&a + 1); &a表示数组的地址，&a+1就相当于&a+sizeof(a),p1指向的就是a[3]后面的地址，p1[-1]被解析成*（p1-1),所以是4.

p2 = (int *)(( int)&a + 1); (int)&a是把数组的地址取出来再转化为一个int类型的数再加1，这时的加1就相当于两个数相加（效果相当于让&a向后偏移一个字节），相加的结果再转化成（int *）地址，使p2指向这个地址。

当前数组的存储：01 00 00 00 02 00 00 00 ........... 因为&a指向的是01这个字节的位置，（int）&a+1的结果是指向了01的下一个字节，这时在强制类型转换成int *，则p2这时指向的空间的内容就是 00 00 00 02，因为是小端存储，所以大端就是 02 00 00 00，输出后就是2000000.

5、二维数组与二级指针参数

（1）、二维数组做参数：

二维数组做参数与一维数组做参数一样，传递的都是首元素的地址，只不过二维数组的每个元素又是一个一维数组。

例：int arr[5][10];

这是一个5行10列的整形数组，可以将它看成一个只有5个元素的一维数组，只不过每个元素又是一个大小为10的一维数组。

我们来分析一下当arr作为实参是，需要什么类型的形参来接受它？？？

arr作为参数时，代表首元素地址，要接受这个地址必须是一个指针或者是一个数组，但是他的每个元素的类型是int[10]。

所以我们可以用一个指向类型为int [10]的数组指针来接受arr[5][10],即：int (*p)[10] 。

同样也可以用一个数组来接受arr，即：int arr1[][10],这里第二维的大小不能省略，在这里int arr1[][10] 也可以被解析成int (*arr1)[10];

（2）、二级指针做参数：

例：char *p[5]；

这是一个大小为5，每个元素都是char *类型的数组，当他作为实参时，需要什么样类型的形参来接受他呢？？？

分析：既然p是一个数组，那么数组在作为实参时，实际上传递过去的是首元素的地址，但是p的每一个元素都是一个char *类型，也是一个地址，所以形参的类型应该是char **。

总结：

数组名只有在sizeof()和取&时才不发生降级，其余地方都代表首元素地址。

6、函数指针

（1）函数指针： 是一个指向函数的指针

声明：

例：void （*p)（）；首先p是一个指针，它指向一个返回值为空，参数为空的函数。

初始化：

要明确，函数指针本质还是一个指针，既然是指针，那么就必须给他进行初始化才能使用它，下面来看一看函数指针的初始化，定义一个返回值为空参数为空的函数：void fun()。

p=fun;

p=&fun;

这两种初始化的方式都是正确的。因为函数名在被编译后其实就是一个地址，所以这两种方式本质上没有什么区别。

调用：

p(）；

（*p)();

这两种方式都是正确的。p里面存的fun的地址，而fun与&fun又是一样的。

例：分析一下（*（void (*) () ) 0 ) ()是个什么东东！！！

首先，void (*) ()；是一个返回值为空，参数为空的函数指针类型。

void (*) () 0 ；它的作用是把0强制类型转换成一个返回值为空，参数为空的函数指针。

(*(void (*) () )0) ；找到保存在0地址处的函数。

（*（void (*) () ) 0 ) ()；对这个函数进行调用。

用途：

1、回调函数：用户将一个函数指针作为参数传递给其他函数，后者再“回调”用户的函数，这种方式称为“回调函数”，如果想要你编写的函数在不同的时候执行不同的工作，这时就可以使用回调函数。回调函数也算是C语言里面为数不多的一个高大上的东西。

2、转换表：转换表本质上是一个函数指针数组，说白了就是一个数组，只不过数组里面存放的全部都是函数指针。

例：实现一个计算器

要求：有“+、-、*、/”四个功能。用户输入操作数，得出结果。

[cpp] view plain copy
#include<stdio.h>  
#include<stdlib.h>  
#include<assert.h>  
int Add(int a, int b)  
{  
  return a + b;  
}  
int Sub(int a, int b)  
{  
 return a - b;  
}  
int Mul(int a, int b)  
{  
 return a *b;  
}  
int Div(int a, int b)  
{  
 assert(b != 0);  
 return a / b;  
}  
int operator(int (*fun)(int,int))   //回调函数  
{  
  int a = 0;  
  int b = 0;  
  printf( "请输入操作数：" );  
  scanf( "%d%d", &a, &b);  
  return (*fun )(a,b);                
}  
int main()  
{  
  printf( "*************************************\n" );  
  printf( "*0.exit           1.Add****\n" );  
  printf( "*2.Sub           3.Mul****\n" );  
  printf( "*4.Div           *********\n" );  
  int(*fun[5])(int ,int);         //转换表  
  fun[1] = Add;  
  fun[2] = Sub;  
  fun[3] = Mul;  
  fun[4] = Div;  
  int input = 1;  
  while (input)  
  {  
    printf( "请选择> " );  
    scanf( "%d", &input);  
    if (input<0 || input>4)  
    {                                             printf( "选择无效\n" );  
    }  
    else if (input == 0)  
    {                                                    break;  
    }  
    else  
    {                                              int ret = operator(fun[input]);  
      printf( "%d\n", ret);  
    }  
  }  
   system( "pause");  
   return 0;  
}  

在这个计算器程序中，就使用到了转换表fun[]。fun[]里面存放了加减乘除四个函数，根据input的不同，fun[input]调用不同的函数。这种方式与switch() case的功能比较相似，不过转换表比switch()case更简单。

（2）、函数指针数组：

函数指针数组是一个指针数组，也就是一个数组，只不过里面存放的全都是函数指针。

声明：例： char* (*p[5])(int,int);

p与[5]先结合成一个数组，所以这是一个大小为5的数组，数组元素的类型是一个函数指针，这个函数指针指向一个返回值为char *，有两个参数，且参数类型为int,int的数组。

可以这样理解：char * (*)(int,int) p[5]; 其中char*(*)(int int)是p[5]的类型。

（3）、函数指针数组的指针：

函数指针数组的指针是一个数组指针，本质上是一个指针，只不过指向的是一个存放函数指针的数组。

声明：例：char *(*(*p)[5])(int,int);

*与p先结合成一个指针，所以p是一个指针，指针所指向的是一个大小为5的数组，这个数组存放的是函数指针，这些函数指针所指向的类型是返回值为char *，有两个int型参数的函数。

可以这样理解： char *(*[5])(int,int) *p; p是一个指针，类型是char*(*[5])(int,int).

总结：指针数组，是一个数组，里面存放的是指针。

数组指针，是一个指针，指向一个数组的指针。

函数指针数组，是一个数组，里面存放的是函数指针。

函数指针数组指针，是一个指针，指向一个存放函数指针的数组。

其实规律很简单，强调的都是最后两个字，最后两个字是什么他就是什么，而前面的字就是他的类型。

三、求内存和长度的差异：

1、整形数组：

int a[] = { 1, 2, 3, 4 };

printf( "%p\n",a); //a代表首元素地址

printf( "%p\n",a+1)； //a+1表示第二个元素的地址

printf( "%p\n",&a); //&a代表整个数组的首地址

printf( "%p\n",&a+1); //&a代表数组的地址，&a+1则跳过整个数组

printf( "%d\n", sizeof (a)); //a在sizeof()中代表整个数组， 16

printf( "%d\n", sizeof (a + 0)); //代表&a[0]，32位下所有的地址大小都为4 4

printf( "%d\n", sizeof (*a))； //表示a[0]，int占4个字节 4

printf( "%d\n", sizeof (a + 1)); //表示&a[1]，32位下所有的地址大小都为4 4

printf( "%d\n", sizeof (a[1])); //表示a[1]，int占4个字节 4

printf( "%d\n", sizeof (&a)); //代表整个数组的地址，32位下所有的地址大小都为4 4

printf( "%d\n", sizeof (&a + 1)); //因为&a代表整个数组地址，&a+1跳过整个数组，但还是一个地址

printf( "%d\n", sizeof (&a[0])); //表示a[0]的地址 4

printf( "%d\n", sizeof (&a[0] + 1)); //表示a[1]的地址 4

printf( "%d\n", sizeof (*&a)); //&a代表整个数组，再*引用访问这块地址，就相当于求取真个数组的大小 16

2、字符数组：

char name[] = "abcdef" ; //这时字符串不代表首元素地址，而是字符数组的一种初始化方式，并且字符串总是默认以’\0‘结尾

printf( "%d\n", sizeof (name[0])); //表示a,32位下char大小为1 1

printf( "%d\n", sizeof (&name)); //表示整个数组的地址，32位下地址就是4 4

printf( "%d\n", sizeof (*name)); //表示 a 1

printf( "%d\n", sizeof (&name+1)); //表示指向整个数组之后的一块空间，但还是一个地址 4

printf( "%d\n", sizeof (name+1)); //表示b的地址 4

printf( "%d\n", sizeof (name)); //代表整个数组，还要加上‘\0' 7

printf( "%d\n", strlen(name)); //求取字符串长度，不包括’\0‘ 6

printf( "%d\n", strlen(&name)); //代表整个数组的地址，&name==name，strlen遇到’\0‘停下 6

printf( "%d\n", strlen(&name + 1)); //是一个随机值，表示指向整个数组之后的一个地址，从这个地址开始向后寻找'\0'，因为’\0‘位置不确定所以是随机值

printf( "%d\n", strlen(name + 1)); //表示b的地址

3、字符指针：

char *name = "abcdef" ; //字符串放在等号右边代表首元素地址

printf( "%d\n", sizeof (name[0])); //以下标形式访问，代表 a 1

printf( "%d\n", sizeof (&name)); //表示字符指针name的地址 4

printf( "%d\n", sizeof (*name)); //通过*访问，表示a 1

printf( "%d\n", sizeof (&name+1)); //表示指针name之后的一块地址 4

printf( "%d\n", sizeof (name+1)); //表示b的地址 4

printf( "%d\n", sizeof (name)); //代表a的地址， 4

printf( "%d\n", strlen(name)); //代表字符串首元素地址 6

printf( "%d\n", strlen(&name)); //表示指针name本身地址，因为从name开始向后’\0‘的位置不确定，所以是个随机值

printf( "%d\n", strlen(&name + 1)); //表示指针name本身地址之后的地址，因为’\0‘的位置不确定，所以是个随机值

printf( "%d\n", strlen(name + 1)); //代表b的地址

转载来自：http://blog.csdn.net/pursh0000/article/details/51448043

阅读全文

0 0