C语言深度解析--指针

目录

指针

指针的定义：

指针的大小：

指针和指针类型

野指针

指针运算

指针+-整数：

指针-指针：

指针的关系运算：

指针和数组

二级指针

指针数组

---

理解指针的第一步是在机器级上观察指针表示的内容。大多数现代计算机都将内存分割为字节(byte)，每个字节可以存储8位的信息。

每个字节都有唯一的地址，用来和内存中的其他字节相区别。如果内存中有n个字节，那么可以把地址看做0~n-1的数。

可执行程序由代码和数据两部分构成。程序中的每个变量占有一个或多个字节内存，把第一个字节的地址称为是变量的地址。

指针

指针的定义：

指针是个变量，存放内存单元地址(编号)的变量。

指针是内存中一个最小单元的编号，也就是地址
口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

指针的大小：

对于32位的机器，每一位均由0或1组成，那么就能产生2^32次方的地址。每个地址标识一个字节，那我们就可以给2^32Byte=4GB的空间进行编址。

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

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

int main()
{
	int a = 10;
	int* pa = &a;

	char ch = 'w';
	char* pc = &ch;

	printf("%d\n",sizeof(pa));//4
	printf("%d\n",sizeof(pc));//4

	return 0;
}

总结：

1. 指针是用来存放地址的，地址是唯一标识一块地址空间的
2. 指针的大小在32位平台是4个字节，在64位平台是8个字节

指针和指针类型

变量有不同的类型，那指针变量有没有类型呢？答案是肯定的。如下所示：

char* pc = NULL;
int* pc = NULL;
short* pc = NULL;
long* pc = NULL;
float* pc = NULL;
double* pc = NULL;

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

那指针类型的意义是什么？

指针+/-整数：

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

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

	printf("\n");

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

	return 0;
}

运行结果：

总结：

指针的类型决定了指针向前或者向后走一步有多大距离。

int*：+1-->+1*sizeof(int)==+4
char*：+1-->+1*sizeof(char)==+1

指针解引用：

案例一：

int main()
{
	int a = 0x11223344;
	int* pa = &a;
	*pa = 0;//操作了四个字节

	return 0;
}

字节的变换：由0x11223344->0x000000，变换了四个字节

 案例二：

int main()
{
	int a = 0x11223344;

	char* pa = &a;
	*pa = 0;//只能操作一个字节，warning C4133: “初始化”: 从“int *”到“char *”的类型不兼容

	return 0;
}

字节的变换：0x11223344->0x11223300，变换了一个字节

案例三：

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

	//假设是按照一个整型的形式访问
	int* p = arr;
	int i = 0;
	for (i = 0; i < 10; i++)
	{
		*p = 0x11223344;
		p++;
	}

	return 0;
}

 字节的变换：每次循环，修改四个字节的内容

 案例四：

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

	//假设访问这40个字节的时候，是以字节为单位访问的
	char* p = (char*)arr;
	int i = 0;
	for (i = 0; i < 40; i++)
	{
		*p = 'x';
		p++;
	}

	return 0;
}

字节的变换： 每次循环，修改一个字节的内容

 总结：

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

野指针

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

野指针成因: 

1.指针未初始化

int main()
{
	int* p;//局部变量指针未初始化，默认为随机值
	*p = 20;

	return 0;
}

2.指针越界访问

int main()
{
	int arr[5] = {1,2,3,4,5};
	int i = 0;
	int* p = arr;
	for (i = 0; i < 10; i++)
	{
		printf("%d ",*p);//当指针指向的范围超出数组arr的范围时，p就是野指针
		p++;
	}
	return 0;
}

3.指针指向的空间释放

int* test()
{
	int a = 10;
	printf("%d\n",a);
	return &a;
}

int main()
{
	int* p = test();//变量a一旦离开test()函数，就自动回收

	*p = 100;

	return 0;
}

如何规避野指针：

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

int main()
{
	int* p = NULL;
	int a = 10;
	p = &a;
	if (p != NULL)
	{
		*p = 20;
	}

	return 0;
}

指针运算

指针+-整数：

指针p加上整数j产生指向特定元素的指针，这个特定元素是p原先指向的元素后的j个位置。更确切地说，如果p指向数组元素a[i]，那么p+j指向a[i+j]。如果p指向数组元素a[i]，那么p-j指向a[i-j]

int main()
{
	int arr[4] = { 1,3,4,5 };
	int* p = arr;
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d ", *p++);//先解引用再++
	}

	printf("\n");

	return 0;
}

指针-指针：

指针-指针的绝对值=指针和指针之间元素的个数

前提：两个指针必须指向同一个数组时，它们相减才有意义

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

	return 0;
}

//实现strlen函数
int my_strlen(char* str)
{
	char* start = str;
	while (*str)
	{
		str++;
	}
	return str - start;
}

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

	return 0;
}

指针的关系运算：

可以用用关系运算符(<,<=,>和>=)和判等运算符(==和!=)进行指针比较。只有在两个指针指向同一数组时，用关系运算符进行的指针比较才有意义。比较的结果依赖于数组中两个元素的相对位置。

标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针进行比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。例如，for语句中的条件p<&a[N]，尽管元素a[N]不存在(数组a的下标从0到N-1)，但是对它使用取地址运算符是合法的。因为循环不会尝试检查a[N]的值，所以在上述方式下使用a[N]是非常安全的。

*运算符和++运算符的组合

*p++或*(p++)	自增前表达式的值是*p，以后再自增p
(*p)++	自增前表达式的值是*p，以后再自增*p
*++p或*(++p)	先自增p，自增后表达式的值是*p
++*p或++(*p)	先自增*p，自增后表达式的值是*p

指针和数组

数组名是数组首元素的地址

a+i等于&a[i];     *(a+i)=a[i]

两个例外：

1. sizeof(数组名)，表示整个数组,计算的是真整个数组的大小
2. &数组名，数组名表示整个数组，取出的是整个数组的地址

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

	printf("%p\n",&arr[0]);
	printf("%p\n", &arr[0] + 1);
	printf("\n");

	printf("%p\n", &arr);
	printf("%p\n", &arr+1);
	printf("\n");
	
	printf("%d\n",sizeof(arr));

	return 0;
}

 运行结果：

使用指针遍历数组：

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

	int* p = arr;//指针存放数组首元素的地址
	int sz = sizeof(arr) / sizeof(arr[0]);

	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ",*(p+i));
	}
	return 0;
}

 惯用法：

for (p = a; p < a + N; p++)
{
	sum += *p;
}

虽然可以把数组名用作指针，但是不能给数组名赋新的值，试图使数组名指向其他地方是错误的：

while (*a != 0)
	a++;

这一限制不会带我们造成什么损失：我们可以把a复制给一个指针变量，然后改变该指针变量：

p = a;
while (*p != 0)
	p++;

二级指针

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

int main()
{
	int a = 10;
	int* pa = &a;//pa是个指针变量(一级指针)

	int* * ppa = &pa;//ppa是一个二级指针，*告诉我们ppa是指针，int*说明ppa指向的对象是int*
	//*ppa通过对ppa中的地址进行解引用，这样找到的是pa，*ppa其实访问的就是pa
	return 0;
}

具体分析：

指针数组

指针数组是个数组，存放的是指针

案例一：

int main()
{
	int a = 10;
	int b = 11;
	int c = 12;
	int d = 13;
	int e = 14;

	int* arr[5] = {&a,&b,&c,&d,&e};

	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ",*(arr[i]));
	}

	printf("\n");

	return 0;
}

运行结果：

案例二：

int main()
{
	int data1[] = {1,2,3,4,5};
	int data2[] = {6,7,8,9,10};
	int data3[] = {11,12,13,14,15};

	int* arr[3] = {data1,data2,data3};

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

	return 0;
}

运行结果：