C语言初阶指针（对指针的初步了解）

月亮有痕迹诶

已于 2023-09-17 17:03:40 修改

阅读量533

点赞数 13

分类专栏： C语言文章标签： c语言 c++

于 2023-09-17 16:57:24 首次发布

本文链接：https://blog.csdn.net/Not_sleep_in/article/details/132929855

版权

C语言专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一、指针是什么

指针是一个变量，其值是另一个变量的内存地址。在计算机编程中，指针常用于直接操作内存中的数据，例如动态内存分配和函数参数传递。通过指针，程序可以直接访问内存中的数据，从而实现高效的数据操作和算法实现。

指针理解的2个要点：

1. 指针是内存中一个最小单元的编号，也就是地址

2. 平时口语中说的指针，通常指的是指针变量，是用来存放内存地址的变量

总结：指针就是地址，口语中说的指针通常指的是指针变量。

#include <stdio.h>

int main()
{
	int a = 10;//在内存中开辟一块空间
	int* p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。
	//a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个之指针变量。

	return 0;
}

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

总结：

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

二、指针和指针类型

我们都知道，变量有不同的类型，整形，浮点型等。那指针有没有类型呢？准确的说：有的。

当有这样的代码：

int num = 10;
p = &num;

要将&num（num的地址）保存到p中，我们知道p就是一个指针变量，那它的类型是怎样的呢？我们给指针变量相应的类型。

char* pc = NULL;
int* pi = NULL;
short* ps = NULL;
long* pl = NULL;
float* pf = NULL;
double* pd = NULL;

这里可以看到，指针的定义方式是： type + * 。

其实：

char* 类型的指针是为了存放 char 类型变量的地址。
int* 类型的指针是为了存放 int 类型变量的地址。
short* 类型的指针是为了存放 short 类型变量的地址。
long* 类型的指针是为了存放long 类型变量的地址。
float* 类型的指针是为了存放float 类型变量的地址。
double* 类型的指针是为了存放double 类型变量的地址。

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

2.1 指针+-整数

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

#include <stdio.h>

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

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

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

    return 0;
}

2.2 指针的解引用

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

例：

//演示实例
#include <stdio.h>

int main()
{
	int n = 0x11223344;

	char* pc = (char*)&n;
	int* pi = &n;

	*pc = 0;   //重点在调试的过程中观察内存的变化。
	*pi = 0;   //重点在调试的过程中观察内存的变化。

	return 0;
}

在这个代码中，当我们查看n在内存中存储的数时，可以发现是44 33 22 11。

代码继续运行，当给*pc为0后，可以看到第一个字节中的44变成了00，而在这里pc为char* 类型的指针。

代码继续运行，当给*pi为0后，可以看到四个字节中的全部变成了00，而在这里pi为int* 类型的指针。

所以验证了char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

三、野指针

野指针是指未初始化或已经被释放的指针，即指向不确定的内存地址的指针变量。在使用野指针时，由于指针变量中存储的地址是未知的或无效的，可能会导致程序崩溃、数据丢失等不可预测的行为。

3.1 野指针成因

1. 指针未初始化

#include<stdio.h>

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

	return 0;
}

2. 指针越界访问

#include<stdio.h>

int main()
{
	int arr[10] = { 0 };
	int* p = arr;
	int i = 0;
	for (i = 0; i <= 10; i++) //i=10的时候越界了
	{
		*p = i;
		p++;
	}

	return 0;
}

3. 指针指向的空间释放

#include<stdio.h>

int* test()
{
	int a = 10;
	return &a;
}

int main()
{
	int* p = test();
	*p = 1;
	printf("%d", *p);

	return 0;
}

3.2 如何规避野指针

指针初始化
小心指针越界
指针指向空间释放即使置NULL
避免返回局部变量的地址
指针使用之前检查有效性

#include <stdio.h>

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

	return 0;
}

野指针是编程中常见的错误之一，发现野指针问题需要仔细排查代码，避免影响程序的正常运行。

四、指针运算

4.1 指针+-整数

指针加减整数是指在指针类型变量上进行算术运算，例如将指针加上一个整数或减去一个整数。

在C/C++中，当将一个整数加上一个指针时，编译器会根据指针类型的大小自动计算出地址偏移量，然后将偏移量加到指针的地址上。例如，假设有一个int类型的指针变量p和一个整数n，那么p+n的结果就是p指向地址的偏移n个int类型的长度。同样的，当将一个指针减去一个整数时，结果也是类似地计算。

需要注意的是，将指针加减整数可能会超出指针所指向的内存范围，因此需要谨慎操作，以避免出现指针越界或内存访问异常的问题。

#include <stdio.h>

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

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

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

    return 0;
}

4.2 指针-指针

指针减指针是指在两个指针类型变量之间进行算术运算，得到它们之间相差的元素数量。

在C/C++中，指针减指针的结果是一个整数，表示它们之间相差的元素个数。例如，假设有两个指向int类型的指针变量p和q，那么p-q的结果就是它们之间相差的int类型元素个数。

需要注意的是，两个指针类型变量之间进行减法运算，要求它们指向同一个数组或同一块内存中的不同元素。否则，结果将没有意义。此外，还需要注意指针的类型大小和对齐方式，以确保减法运算的结果正确。

#include <stdio.h>

int main()
{
	int arr[10] = { 0 };
	
	//指针-指针的前提：两个指针指向同一块区域，指针类型时相同的
	//指针-指针差值的绝对值，指针和指针之间的元素个数
	
	printf("%d\n", &arr[9] - &arr[0]);
	printf("%d\n", &arr[0] - &arr[9]);

	return 0;
}

4.3 指针的关系运算

指针可以进行关系运算，包括大于、小于、等于、大于等于、小于等于、不等于等六种运算。

关系运算符的使用方法和普通变量的使用方法是一样的，如>、<、>=、<=、==、!=。其规则如下：

1. 当两个指针指向的是同一个数组、同一个对象、同一个函数或者同一块内存区域时，可以直接进行关系运算符的运算。比较的是指针所指向元素的地址大小关系。

2. 当两个指针指向的不是同一个数组、同一个对象、同一个函数或者同一块内存区域时，就不能直接进行关系运算符的运算。

需要注意的是，指针的比较结果是一个布尔值，即true和false，分别代表指针之间的大小关系成立和不成立。

#include <stdio.h>

int main()
{
	int arr[10];
	int* p;
	for (p = &arr[10]; p > &arr[0];)
	{
		*--p = 0;
	}
	
	return 0;
}

五、指针和数组

指针和数组有密切的关系，可以互相转换。

首先，数组名是一个指向数组第一个元素的指针。例如，对于一个名为arr的数组，arr表示指向arr[0]的指针。因此，可以用指针的方式访问数组元素，例如*(arr+1)表示访问arr[1]这个元素。

其次，指针也可以指向数组。指向数组的指针可以用来访问数组中的元素，例如int *p = arr表示将指针p指向数组arr的第一个元素arr[0]。

需要注意的是，指针和数组的关系需要根据具体的场景进行判断。如果需要对数组进行元素的添加、删除、插入等操作，建议使用数组；如果需要使用动态内存分配或者在函数中对数组进行传参，建议使用指针。

如下代码可验证数组名表示的是数组首元素的地址：

#include <stdio.h>

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

	return 0;
}

如下代码用指针访问数组：

#include<stdio.h>

int main()
{
	int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
	//            0 1 2 3 4 5 6 7 8 9
	//使用指针打印数组的内容
	int * p = arr;
	int i = 0;
	//arr-->p
	//arr == p
	//arr+i  ==  p+i
	//*(arr+i) == *(p+i) == arr[i]
	//*(arr+i) == arr[i]
	//*(i+arr) == i[arr]
	//3+5
	//5+3
	for (i = 0; i < 10; i++)
	{
		printf("%d ", *(p + i));
		printf("%d ", *(arr + i));
		printf("%d ", arr[i]);
		printf("%d ", i[arr]);
		printf("%d ", i[p]);
		printf("\n");

		//p指向的是数组首元素
		//p+i 是数组中下标为i的元素的地址
		//p+i 其实是跳过了i*sizeof(int)个字节
	}
	return 0;
}

六、二级指针

二级指针是指一个指针变量的值是另一个指针变量的地址，也就是说，它指向的是一个指针的指针。一级指针是指一个指针变量保存的是某个对象的地址，而二级指针保存的是一个指向指针变量的指针的地址。

在 C 语言中，二级指针通常用于函数参数和动态内存分配中。例如，在函数中传递一个指针的指针作为参数，可以通过这个指针的指针修改原指针的值。具体来说，可以用一个二级指针将指针变量的地址传递给函数，然后在函数中通过二级指针访问这个指针变量，通过修改这个指针变量的值来实现对原指针的修改。

另外，使用二级指针进行动态内存分配也很常见。例如，在动态分配一个二维数组时，需要使用二级指针来管理内存空间。可以先分配一维的数组指针，再分别为每个指针分配一维的数组空间，最终得到一个二维数组。

#include<stdio.h>

int main()
{
	int a = 10;
	int* p =  &a;//p是指针变量，一级指针变量
	int** pp = &p;//pp指针变量，二级指针变量

	**pp = 20;
	printf("%d\n", a);//20

	//int** * ppp = &pp;//pp是指针变量，三级指针变量
	//...
	return 0;
}

七、指针数组

指针数组是由一组指针构成的数组。每个指针都指向内存中的一个对象，这些对象可以是相同的类型，也可以是不同的类型。指针数组可以使用下标访问，每个元素都是一个指针。

指针数组在 C 语言中应用非常广泛，常用于动态内存分配、字符串处理、多维数组等场景。使用指针数组可以避免在循环中频繁地进行指针运算，提高代码的效率。同时，指针数组可以方便地处理不同类型的数据结构。

下面是一个指针数组的示例代码，其中包含三个指针，每个指针分别指向一个 int、char 和 double 类型的变量。

#include<stdio.h>

int main()
{
	int a = 10;
	char b = 'c';
	double c = 3.14;

	int* ptr1 = &a;
	char* ptr2 = &b;
	double* ptr3 = &c;

	void* ptrArr[] = { ptr1, ptr2, ptr3 };//指针数组

	return 0;
}