c语言—指针详解_c语言指针

一、指针是什么

指针，是C语言中的一个重要概念及其特点，也是掌握C语言比较困难的部分。指针也就是内存地址，指针变量是用来存放内存地址的变量，不同类型的指针变量所占用的存储单元长度是相同的，而存放数据的变量因数据的类型不同，所占用的存储空间长度也不同。有了指针以后，不仅可以对数据本身，也可以对存储数据的变量地址进行操作。

总结：

• 指针就是地址，地址就是指针。
• 使用指针的目的是提高使用效率
• 指针是用来存放地址的，地址是唯一标示一块地址空间的。
• 指针的大小在32位平台是4个字节，在64位平台是8个字节。

二、指针和指针变量

1.左值与右值

空间 对应 左值

例：（对a来说）
a = 20; //当把值赋给a时，是给a的空间写入20。

内容 对应 右值
例：（对a来说）
b = a; //把a的内容赋给b。

2.两者的区别

指针
指针就是地址，地址就是指针。

指针变量
指针变量是变量。定义一个指针变量，是在内存中开辟一个空间，该空间里面存放地址。

如何使用
指针更多强调的是内容（对应右值），指针变量更多强调的是空间（对应左值）。判断一个指针和一个指针变量要通过判断它是左值还是右值。

    int *p = &a;  //定义了指针变量p
    p = &b;  //将b的地址放在p的空间
    int *q = p;  //定义了指针变量q，把p的内容（地址）给了q（空间）
1
2
3

大部分使用的都是指针变量，但是书中经常简称定义一个指针，这种说法并没有错，这时通过上下文，通过左值和右值进行判断。

指针和指针变量不一样，严格来说，定义一个指针是个错误的说法。但是，在日常生活中，还是将指针和指针变量混在一起使用,因为大部分人和书将指针和指针变量混在一起。既可以说定义一个指针，也可以说定义一个指针变量，它到底是什么需要自己判断。

三、指针和指针类型

1.定义指针

char  *pc = NULL;
short *ps = NULL;
int   *pi = NULL;
long  *pl = NULL;
float *pf = NULL;
double *pd = NULL;
1
2
3
4
5
6

这里可以看到，指针的定义方式是：type + *。 其实： char*类型的指针是为了存放 char类型变量的地址。 short* 类型的指针是为了存放short类型变量的地址。int*类型的指针是为了存放int 类型变量的地址。

2.大小端

为什么有大小端区别之分

这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于 8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。即如何存放高低权值位在高低地址中。

小端：将低权值数据放入低地址字节中
大端：将低权值数据放入高地址字节中

3.指针的解引用

对指针对解引用代表指针所指向的目标

#include <stdio.h>
int main()
{
 int n = 0x11223344;
 char* pc = (char*)&n;
 int* pi = &n;
 *pc = 0;
 *pi = 0; 
 return 0;
}
1
2
3
4
5
6
7
8
9
10

作图分析：

逐步分析：
第一步：
可看出此时是小端存储

第二步：
将该数的第一个字节清0了

第三步：
将该变量整个清0了

总结： 指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。 比如： char*的指针解引用就只能访问一个字节，而 int*的指针的解引用就能访问四个字节。

四、野指针

概念

野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因

1.指针未初始化

#include <stdio.h>
int main()
{ 
 int *p;//局部变量指针未初始化，默认为随机值
    *p = 20;
 return 0; }
1
2
3
4
5
6

2.指针访问越界

#include <stdio.h>
int main()
{
    int arr[10] = {0};
    int *p = arr;
    int i = 0;
    for(i=0; i<=11; i++)
   {
        //当指针指向的范围超出数组arr的范围时，p就是野指针
        *(p++) = i;
   }
    return 0; }
1
2
3
4
5
6
7
8
9
10
11
12

3.指针指向的空间释放
略…

如何规避野指针

1. 指针初始化
2. 小心指针越界
3. 指针指向空间释放即使置NULL
4. 指针使用之前检查有效性

五、指针运算

1.指针± 整数

#include <stdio.h>
int main()
{
 int n = 10;
 char *pc = (char*)&n;
 int *pi = &n;
 
 printf("%p\n", &n);
 printf("%p\n", pc);
 printf("%p\n", pc+1);
 printf("%p\n", pi);
 printf("%p\n", pi+1);
 return  0; }
1
2
3
4
5
6
7
8
9
10
11
12
13

输出结果：

对指针加1或 减1代表对其改变指针所指向类型的大小

2.指针-指针

两个指针相减代表指针之间所经历的元素（由参与运算的指针类型决定）个数

int my_strlen(char *s) {
       char *p = s;
       while(*p != '\0' )
              p++;
       return p-s; }
1
2
3
4
5

3.指针的关系运算

标准规定：

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。

接下来看三段代码的指针的指向。

代码一是开始指向数组首元素，最后指针指向整个数组的后一项

#define N_VALUES 5
float values[N_VALUES];
float *vp;
//代码一
for (vp = &values[0]; vp < &values[N_VALUES];)
{
     *vp++ = 0; }
1
2
3
4
5
6
7

代码二开始指向数组的后一项，最后指向数组的第一项

//代码二
for(vp = &values[N_VALUES]; vp > &values[0];)
{
    *--vp = 0; }
1
2
3
4

代码三开始指向数组最后一项，最后指向整个数组的前一项

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--) {
    *vp = 0; }
1
2

实际在绝大部分的编译器上是可以顺利完成任务的，然而我们还是应该避免这样写，因为标准并不保证它可行。

六、指针和数组

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int* p = arr;
	printf("%p\n", arr+1);
	printf("%p\n", p+1);
	printf("%d\n",arr[1] );
	printf("%d\n", *(p + 1));

	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

输出结果：

所以可以用指针保存数组首元素地址，使用指针进行访问数组元素。
但是，需要注意

七、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？ 这就是二级指针

对于二级指针的运算有：

• *pp通过对pp中的地址进行解引用，这样找到的是 p ， *pp其实访问的就是p .

int a = 20; 
*pp = &a;//等价于 p = &a;
1
2

• **pp 先通过 *pp 找到 p ,然后对 p 进行解引用操作：*p ，那找到的是 a .

**pp = 10;
//等价于*p = 10;
//等价于a = 10;
1
2
3

结论

1. 二级指针及以上的指针自加1是加上4字节（32位系统）或8字节（64位系统）
2. 一级指针自加1就是加上所指向类型的大小

八、指针数组和数组指针

• 数组指针：是指针，指向数组。例：int (*arr)[10]
• 指针数组：是数组，数组内容存放的是指针。例：int *arr[10]

然后，需要明确一个优先级顺序：()>[]>*
所以：
(*p)[n]：根据优先级，先看括号内，则p是一个指针，这个指针指向一个一维数组，数组长度为n，这是“数组的指针”，即数组指针；
*p[n]：根据优先级，先看[]，则p是一个数组，再结合*，这个数组的元素是指针类型，共n个元素，这是“指针的数组”，即指针数组。

1.指针数组

具体使用：

#include<stdio.h>

int main(void)
{
        int *p[4];
        int arr1[3] = { 1,2,3 };
        int arr2[4] = { 2,4,6,8 };
        int arr3[5] = { 0 };
        int arr4[2] = { 2,2 };
        p[0] = arr1;
        p[1] = arr2;
        p[2] = arr3;
        p[3] = arr4;
        printf("%d\n", *(p[0] + 1));
        printf("%d\n", *(p[1] + 1));
        printf("%d\n", *(p[2] + 1));
        printf("%d\n", *(p[3] + 1));

        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

输出结果：

首先，对于语句int*p[4]，因为[ ]的优先级要比*要高，所以 p 先与[ ]结合，构成一个数组的定义，数组名为 p，而int*修饰的是数组的内容，即数组的每个元素。也就是说，该数组包含 4 个指向int类型数据的指针，如图所示，因此，它是一个指针数组。

2.数组指针

使用：

#include<stdio.h>

int main(void)
{
        int Shuzu[3][4] = { 0,1,2,3,4,5,6,7,8,9,0,0 };
        int(*arr)[4] = Shuzu;
        for (int i = 0;i < 3;i++)
        {
               for (int j = 0;j < 4;j++)
               {
                       printf("arr[%d][%d]=%d  ", i,j,arr[i][j] );
               }
               printf("\n");
        }

        return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

结果为：

其次，对于语句int(*arr)[4]，“( )”的优先级比[ ]高，*号和 arr 构成一个指针的定义，指针变量名为arr，而int 修饰的是数组的内容，即数组的每个元素。也就是说，arr 是一个指针，它指向一个包含 4 个int类型数据的数组，如图 所示。很显然，它是一个数组指针。