C语言——指针（入门详解）

1.什么是指针？

1.1.理解指针的两个要点：

1.指针是内存中最小单元的编号，也就是地址。
2.平时口语中的指针，通常指的是指针变量，指针变量是用来存放内存地址的变量。
总结：指针其实就是地址，口语中的指针通常指的是指针变量。

补充：一个内存单元占一个字节。

1.2.指针变量：

通过&取地址操作符取出变量在内存中的起始地址，将取出的地址存放在一个变量中，这个存放地址的变量就是指针变量。

下面通过代码演示指针变量的创建与使用

int main()
{
	int a = 10;
	int* pa  = &a;//创建指针变量并初始化

	//打印验证
	printf("%p\n", &a);
	printf("%p\n", pa);

	//使用指针变量需要用*解引用操作符
	*pa = 20;//此时*pa等价与a
	printf("%d\n", *pa);
	printf("%d\n", a);


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

补充：

1、a在内存中占4个字节，&a取出的是整型变量a的第一个字节的地址（最小的地址）。
2.当需要通过地址访问来改变变量的值时，需要使用*解引用操作符对指针变量进行解引用操作。

1.3.内存是如何编址？

对于32位的机器，假设有32根地址线，那么假设每根地址线在寻址的时候产生高电平（高电压）和低电平（低电压）就是（1或者0）。

每个地址标识1个字节，操作系统就会分配2的32次方个字节，也就是4GB的空间进行编址。同理可得64位机器，每个地址标识2个字节，操作系统就会分配2的64次方个字节，也就是8GB的空间进行编址。

在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结：

1、指针变量是用来存放地址的，地址是唯一标识一个内存单元的。
2、在32位平台下，地址的大小是4个字节，指针变量的大小是4个字节。在64位平台下，地址的大小是8个字节，指针变量的大小也是8个字节。

2.指针和指针类型

2.1指针的创建与初始化

我们都知道变量是分类型的，如整型、单精度浮点型、字符型等。那指针是否也分类型呢？答案是有的。
下面我通过代码举例

int main()
{
	int a = 10;
	//创建整型指针变量pa并初始化
	int* pa = &a;//将变量a的地址存放到指针变量pa中
	
	return 0;
}
1
2
3
4
5
6
7
8

上例中，我将变量a的地址存放到指针变量pa中。pa的类型是int*（整形指针）。由此我们可以得到
指针的定义方式是：

type（类型） + * +prt_name(指针变量名字)

其实：
char* 类型的指针是为了存放 char 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。

让我们来看看第二个例子

int main()
{
	int a = 10;
	char* pc = &a;
	//char*类型的指针能否得存放int类型变量的地址呢？
	return 0;
}
1
2
3
4
5
6
7

答案是：能够存放。因为一个指针变量在32位环境下都是占4个字节。这里不要门缝里看char*类型指针，把它给看遍了。这也是我们需要注意的一个小细节。

既然指针变量的大小在32位平台下都是4个字节，那指针变量的类型存在的意义是什么呢？

2.2.指针类型

这里我依旧是通过两段代码进行举例

//例一
#include 

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
14
15
16

通过上面的例子我们可以发现，指针的类型决定了指针+1后访问的步长。int类型指针+1向后移动了4个字节，char类型指针+1向后移动了1个字节。同理可得short类型指针+1向后移动2个字节，float类型指针+1向后移动4个字节。

总结

指针变量的类型决定了指针的步长（向前或向后走一步的距离）。

//例二

int main()
{
	int a = 0x11223344;//0x表示十六进制类型

	char* pc = (char*)&a;
//a是整型，需要对&a进行强制类型转换成char*后编译器才不会报错
	int* pi = &a;

	*pc = 0;   
	*pi = 0;   

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

先调试这段代码

让我们看看pc = 0的效果

接下来是pi = 0；这句代码的效果

通过调试的内存窗口，可以发现当对char类型指针变量进行解引用操作后，访问的权限是1个字节，而对int类型指针变量进行解引用访问操作，访问的权限是4个字节。所以指针变量的类型其实是由意义的。

总结：

指针变量的类型决定了解引用操作后的指针的访问权限。int类型指针变量解引用操作访问权限是4个字节，char类型指针变量解引用操作访问权限是1个字节。

3.野指针

3.1.什么视野指针？

野指针的概念

野指针指的是指向不可知的指针变量（随机的、不正确的、不可控的）。

3.2.野指针成因

1.指针变量未进行初始化

int main()
{
	int* pa;
	*pa = 20;
	return 0;
}
1
2
3
4
5
6

上例中，指针变量pa未进行初始化，所以pa是一个野指针，对pa进行仅引用操作是极其危险的，因为pa的指向是不可知的。

指针越界访问

int main()
{
	int arr[5]={1,2,3,4,5};
	int *p = arr;
	int i = 0;
	
	for(i = 0; i <= 5; i++)
	{
		*(p++) = i;
	}
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

当运行这段代码后，编译器会进行报错

这里编译器告诉我们因为指针访问越界，数组arr被破坏了。所以当p超出数组的合理范围后，p就是一个野指针，对野指针进行解引用操作是很危险的。

3.3.规避野指针

1.创建指针变量同时初始化指针变量。
2. 小心指针越界。
3. 指针指向空间释放，及时置NULL。
4. 避免返回局部变量的地址。
5. 指针使用之前检查有效性。

4.指针运算

4.1.指针±整数

代码举例如下

#include

int main()
{
	int arr[5] = { 0 };
	int* pa = arr;
	int i = 0;
	//将数组内容赋值成1~5
	for (i = 0; i < 5; i++)
	{
		*pa = i + 1;
		pa = pa + 1;//指针加整数
	}
	//打印数组内容
	for (i = 0; i < 5; i++)
	{
		printf("%d ", arr[i]);
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

4.2.指针-指针

指针-指针的前提条件是，两个指针变量指向同一块空间。

int main()
{
	int arr[10] = { 0 };
	int* pa = &arr[9];
	int* pb = &arr[0];
	//此时pa和pb都是指向数组arr的内容
	printf("%d\n",pa - pb);

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

指针-指针得到的绝对值是，两个指针之间相同类型的元素的个数。

下面我通过指针-指针的方式模拟实现库函数strlen

#include

size_t MyStrlen(const char* str)
{
	assert(str != NULL);

	char* start = str;//记录初始地址

	while (*str++)
	{
		;
	}
	//通过指针-指针返回字符串长度
	return str - start - 1;

}

int main()
{
	char str[] = "abcde";
	
	printf("%d\n",MyStrlen(str));

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

4.3指针的关系运算

#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float *vp;
	//								指针的关系运算
	for(vp = &values[N_VALUES]; vp > &values[0];)
	{
    	*--vp = 0;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

将上边的代码稍作修改

#define N_VALUES 5
int main()
{
	float values[N_VALUES];
	float *vp;
	//								指针的关系运算
	for(vp = &values[N_VALUES]; vp > &values[0];vp--)
	{
    	*vp = 0;
	}
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

代码修改后，看起来是更易读了，可是我们应该避免这样写代码。虽然上面的代码在市面上绝大部分编译器都可以正常运行，但是C语言标准中并不能保证它是对的。

C语言标准规定：
允许指向数组元素的指针与指向数组的最后一个元素后面那个内存空间的指针作比较，但是不允许与第一个元素前面那个内存空间的指针进行比较。

5.指针与数组

指针和数组是不同的对象。指针是一种用来存放地址的变量，大小是4/8个字节。数组是一组相同类型元素的集合，可以放多个元素，大小取决于元素个数和元素类型的。数组的数组名是数组首元素的地址，地址是可以存放在指针变量中的。可以通过指针来访问数组。

#include
int main()
{
	int arr[10] = {0};
	
	printf("%p\n",arr);
	printf("%p\n",&arr);
	return 0;
}
1
2
3
4
5
6
7
8
9

由上例可知，数组名本质是首元素的地址（排除&数组名和sizeof(数组名)这两种情况）。既然数组名是数组首元素的地址，我们不妨将数组名存入一个指针变量中，再通过这个指针变量来遍历整个数组。

#include

int main()
{
    int arr[] = { 1,2,3,4,5,6,7,8,9,0 };
    int* p = arr; //指针存放数组首元素的地址
    int sz = sizeof(arr) / sizeof(arr[0]);
    int i = 0;
    for (i = 0; i < sz; i++)
    {
        printf("&arr[%d] = %p   <====> p+%d = %p\n", i, &arr[i], i, p + i);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

可以发现其实 p+i 是完全等价于 arr[ i ]的。接下来试试通过指针运算来便利整形数组并且打印数组

int main()
{
	int arr[10] = {0};
	int* pa = arr;
	int sz = sizeof(arr)/sizeof(arr[0]);
	int i = 0;
//改变数组内容1~10
	for(i = 0; i < sz; i++)
	{
		*pa = i + 1;
		pa++;
	}
	pa = arr;//重新指定指针的位置以避免越界
//打印数组内容
		for(i = 0; i < sz; i++)
	{
		printf("%d ",*pa);
		pa++;
	}

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

int main()
{
	int arr[10] = {0};
	int* pa = arr;
	int sz = sizeof(arr)/sizeof(arr[0]);
	int i = 0;
//改变数组内容1~10
	for(i = 0; i < sz; i++)
	{
		*(pa+i) = i + 1;
	}

//打印数组内容
		for(i = 0; i < sz; i++)
	{
		printf("%d ",*(pa+i));
	}

	return 0;
}

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

补充：
[ ]下标访问操作符两边，arr 和 i 是下标访问操作符的两个操作数。[ ]下标访问操作符是支持交换律的，所以 arr[ i ] 等价于 i[arr]。

6.二级指针

6.1.什么是二级指针

指针变量是用来存放地址的，那指针变量的地址该存放到哪里呢？这就要引出二级指针这个概念了。二级指针是用来存放指针变量的地址的。

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	return 0;
}
1
2
3
4
5
6
7

6.2.二级指针的运算

通过 * 解引用操作符对二级指针进行解引用操作。

int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	**ppa = 20;//*(*ppa) =*(pa) = a; 
	//通过对* *ppa进行解引用操作得到pa,再通过对pa进行解引用操作得到a
	//**ppa等价于a
	printf("%d\n", a);
}
1
2
3
4
5
6
7
8
9
10

7.指针数组

指针数组是什么呢？是数组？还是指针？答案是：指针数组是用来存放指针的数组。通过前面的学习，我们了解到的数组类型有字符数组、整型数组、单精度浮点型数组等。

int arr[] = {1,2,3,4,5};
char ch[] = {'a', 'b', 'c'};
1
2

int* arrp[] = {0x0012ff40, 0x0012ff41, 0x0012ff42};

1
2

下面我通过一个指针数组加三个一维数组来模拟实现二维数组

#include

int main()
{
	int arr1[3] = { 1,2,3 };
	int arr2[3] = { 4,5,6 };
	int arr3[3] = { 7,8,9 };

	int* arrp[3] = { arr1,arr2,arr3 };

	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		for (j = 0; j < 3; j++)
		{
			printf("%d ",arrp[i][j]);//arr[i]相当于是arr[列号]。通过指针运算，就可以遍历整个数组。
		}
	printf("\n");
	}

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

通过了访问指针数组arrp中存放的三个整形数组的首元素地址，然后再通过指针运算，就可以模拟实现一个二维数组了。

总结

总有人说指针多难多难，在我看来只要搞清楚指针的概念以及指针的用法，理解指针也不是特别难的。这只需要我们多去思考和总结。学习没有捷径，只有你真的认真学了才能够真正的掌握知识。最后，也希望看完本篇文章的你有所收获，有什么问题也欢迎在评论区进行讨论。