【Amazing! C】初识指针（一）_amazing!c语言-优快云博客

本文链接：https://blog.youkuaiyun.com/jp_yc/article/details/139755814

前言

之前听人讲过，C语言中最难的就是指针，导致我先入为主的一直没有接触指针。但是反过来想想，越难学懂的知识却恰恰证明了其重要性。我们要把指针视为paper tiger，不要怕学不会，因为再难的知识也可以一点一点的积累学明白。

一、指针是什么

首先，我们举个例子：我们去教学楼上课之前，肯定会去确认在哪一间教室，比如教学楼C区502，因此，我们会根据这个信息直接快速的找到对应的教室。

那么，相同的道理：在计算机中，CPU在处理数据时需要在内存中获取指定数据，同时将处理结果存放在内存的特定位置上。那么，内存空间是怎样有效的管理数据呢？

我们知道，内存是被划分成一个一个的内存单元，单位是字节（byte），每个内存单元被赋予了相应的编号，CPU可以通过这个编号快速的在内存中找到特定的数据。这个编号是存放数据的地址，在C语言中，称为指针。指针就是地址，如图所示：

平常口头说的指针，通常指的是指针变量，用来存放内存地址的变量。

#include<stdio.h>

int main()
{
	int a = 10;//向内存中的栈区空间申请4个字节的空间，这4个字节用来存放10这个数值
	int* pa = &a;//*说明是指针变量，int说明pa指向的a是int类型   pa的类型是int*

	return 0;
}

把数据通过地址存放在相应的内存中，那么地址是怎么设定的呢？CPU和内存之间是通过连接线进行数据交换的，这里我们称之为地址总线。所以，我们还需要知道32根线和64根线。

32位机器有32根线，64位机器有64根线，在32位机器上，地址是32个0或1组成的二进制序列，经过排列组合，共有2^32种情况，情况如下：

每次组合都代表1个地址，一个地址需要用4个字节的空间来储存，所以1个指针的大小是4个字节，此处又要提到，不要在门缝里看指针把指针看扁了。同时，32位机器的内存为2^32byte = 4GB。

总结

内存被划分成一个个的内存单元，每个内存单元的大小是1个字节
每个字节的内存单元都有一个编号，这个编号就是地址，地址在C语言中称为指针
地址要存储的话，存放在指针变量中
每个内存单元都有一个唯一的地址来标识
在32位机器下，地址的大小是4个字节，所以指针变量的大小也是4个字节。同理，在64位机器下，地址的大小是8个字节，所以指针变量的大小也是8个字节

有人说：一个地址管理一个字节，却要用4个字节储存。

这句话是有问题的，因为，地址并不是都要存起来的，因为32根线的电信号产生二进制序列，会直接找到对应的内存单元，并不需要存起来，只有把地址放在指针变量中才需要存起来。

二、指针和指针类型

同数据类型一样，指针类型也包括整型、字符型、浮点型等。

#include<stdio.h>

int main()
{
	printf("%d\n", sizeof(char*));//4
	printf("%d\n", sizeof(short*));//4
	printf("%d\n", sizeof(int*));//4
	printf("%d\n", sizeof(double*));//4

	return 0;
}

既然都是4，为什么还有区分char*、short*、int*、double*?换句话说，指针类型有什么用？我们通过代码进行了解。

#include<stdio.h>

int main()
{
    int a = 0x11223344;
    int b = 0x11223344;
    char * cp = &a;
    *cp = 0;//00 33 22 11

    int * p = &b;
    *p = 0;//00 00 00 00

    return 0;
}

经过对比发现，指针类型是有意义的：

指针类型决定了指针进行解引用操作的时候，访问几个字节。

char*类型解引用访问1个字节
short*类型的解引用访问2个字节
int*类型的解引用访问4个字节

2.1 指针+-整数

我们通过代码来理解指针加减整数：

#include<stdio.h>

int main()
{
	int a = 0;
	int* pa = &a;
	char* pc = &a;

	printf("pa = %p\n", pa);
	printf("pa+1 = %p\n", pa+1);

	printf("pc = %p\n", pc);
	printf("pc+1 = %p\n", pc+1);

	return 0;
}

由此我们可以看出，指针的类型决定了指针向前或者向后走一步有多大（距离）。同时也证明了指针类型是有意义的。指针类型加1或减1，决定了内存向前或向后跳过几个字节。

   int* 的指针+1，跳过4个字节
   char* 的指针+1，跳过1个字节
   short* 的指针+1，跳过2个字节
   double* 的指针+1，跳过8个字节

2.2 指针的解引用

2.2.1 整型解引用

#include<stdio.h>

int main()
{
	int arr[10] = { 0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344 };

	int* p = arr;
	int i = 0;

	for (i = 0; i < 10; i++)
	{
		*p = 0;
		p++;
	}

	return 0;
}

2.2.2 字符型解引用

#include<stdio.h>

int main()
{
	int arr[10] = { 0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,0x11223344 };

	char* p = arr;
	int i = 0;

	for (i = 0; i < 10; i++)
	{
		*p = 0;
		p++;
	}

	return 0;
}

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

三、野指针

野指针就是指针指向的位置是不可知的（随机的，不正确的，没有明确限制的）。例如：

int main()
{
	int* p = (int*)0x11223344;//随便捏造了一个地址放在p中
	*p;//然后通过解引用访问地址所指向的空间
	//就像非法打电话一样
	return 0;
}

3.1 野指针的成因

3.1.1 指针未初始化

int main()
{
	int* p;
	*p = 10;

	return 0;
}

3.1.2 指针越界访问

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 10; i++)//循环11次
	{
		*p = -1;
		p++;
		//*p++ = -1;
	}

	return 0;
}

3.1.3 指针指向的空间释放

int* test()
{
	int a = 10;//创建了局部变量10，假如存放的地址是0x0012ff40
	return &a;//返回地址
}
int main()
{
	int* p = test();
	//p就是野指针
	//接收返回的地址0x0012ff40
	//但出了test函数之后，int a = 10占用的4个字节已经释放，栈空间销毁，再记住地址也已经找不到原来的内容
	//例如住1天酒店，退了以后再通过地址找过去，就是一个不合理信息
	printf("%d\n", *p);
	return 0;
}

3.2 如何规避野指针

1.指针初始化
1.1如果明确指针应该指向哪里，就初始化正确的地址
   int a = 10;
   int* p = &a;
1.2如果指针不知道初始化什么值，为了安全，初始化NULL(空指针，就是0)
   int* p = NULL;//0，0作为地址时，这个地址用户程序是不能访问的
2.小心指针越界
3.指针指向空间释放，及时置NULL
4.避免返回局部变量的地址
5.指针使用之前检查有效性

四、指针运算

4.1 指针+-整数

我们写一个代码，要求使用指针打印数组中的所有元素，代码如下：

#include<stdio.h>

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

    return 0;
}

   arr == p
   那么可以说arr+i == p+i
   *(arr+i) == *(p+i) == arr[i]
   所以想表达的是：* (arr+i) == arr[i]
   那么根据交换律：* (i+arr) == i[arr]，因为[ ]是一个操作符
   在编译器中，数组arr[i]会转化为*(arr+i)的形式。

我们使用指针，对数组的所有元素全部赋值0。

代码1：

#define N_VALUES 5

float values[N_VALUES];
float * vp;

for(vp = &values[0]; vp < &values[N_VALUES]; )
{
    * vp++ = 0;
}

代码2：

#define N_VALUES 5

float values[N_VALUES];
float * vp;

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

虽然，上述两个代码看似功能一致，但是标准规定，允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但不允许与指向第一个元素之前的那个内存位置的指针进行比较。

4.2 指针-指针

#include<stdio.h>

int main()
{
    int arr[10] = { 0 };
    printf("%d\n", &arr[9] - &arr[0]); //9
    
    printf("%d\n", &arr[0] - &arr[9]); //-9

    return 0;
}

我们通过代码可以知道，指针-指针差值的绝对值，得到的是指针和指针之间的元素个数。但前提是两个指针指向同一块区域，指针类型是相同的。

基于这样一个特性，我们写一个代码，模拟实现strlen，计算字符串长度。代码如下：

#include<stdio.h>

size_t my_strlen(char * str)
{
    char start = str;
    while(*str != '\0')
    {
        str++;
    }
    return str - start;
}

int main()
{
    char arr[] = "abcdef";
    int len = my_strlen(arr);
    printf("%d\n", len);
    
    return 0;
}

五、指针和数组

首先，我们要明确：

指针就是指针，指针变量就是一个变量，用来存放地址，指针变量的大小是4或8个字节。
数组就是数组，可以存放一组数，数组的大小是取决于元素的类型和个数。

放在一起的原因是，数组的数组名是数组首元素的地址，地址是可以放在指针变量中的。

数组名表示数组首元素的地址，但是有两个例外：

sizeof(数组名)，数组名单独放在sizeof内部，数组名表示整个数组，计算的是数组的大小，单位是字节；
&数组名，数组名表示整个数组，取出的是数组的地址，数组的地址和数组首元素的地址，值是一样的，但是类型和意义是不一样的。

我们有如下代码证明：

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };

	printf("%p\n", arr);//类型是int*
	printf("%p\n", arr+1);//跳过4个字节

	printf("%p\n", &arr[0]);//类型是int*
	printf("%p\n", &arr[0]+1);//跳过4个字节

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);//跳过整个数组，40个字节

	printf("%d\n", sizeof(arr));

	return 0;
}

基于上述特性，我们可以知道，数组是连续存放的，那么可以通过指针偏移去访问数组。代码如下：

#include<stdio.h>

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

六、二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪里？因此，我们引入二级指针变量，二级指针变量就是用来存放一级指针变量的地址。

#include<stdio.h>

int main()
{
	int a = 10;
	int* p = &a;//p是指针变量，一级指针变量
	int* * pp = &p;//pp是指针变量，二级指针变量		第二个*说明pp是指针，而前边的int*说明pp所指向的对象p的类型是int*
	int** * ppp = &pp;//ppp是指针变量，三级指针变量

	**pp = 20;//先通过*pp找到p，再对p解引用，找到a
    //等价于*p=20；继续等价于a=20

	printf("%d\n", a);

	return 0;
}

七、指针数组

我们知道，指针就是指针，数组就是数组。那么指针数组是指针还是数组？这里给出回答：

指针数组是数组，是存放指针（地址）的数组。

等同于字符数组和整型数组。分别是存放字符型和整型的数组。

char* arr1[5];//存放字符指针的数组
double* arr2[4];//存放字符指针的数组

我们写一个代码，使用指针数组，模拟一个二维数组：

#include<stdio.h>

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

	//arr就是指针数组
	int* arr[3] = { arr1,arr2,arr3 };

	int i = 0;
	for (i = 0; i < 3; i++)				
	{									
		int j = 0;						
		for (j = 0; j < 5; j++)			
		{								
			printf("%d ", arr[i][j]);	
		}								
		printf("\n");					
	}
	return 0;
}