C语言初阶指针(对指针的初步了解)

目录

一、指针是什么

二、指针和指针类型

2.1 指针+-整数

2.2 指针的解引用

三、野指针

3.1 野指针成因

3.2 如何规避野指针

四、指针运算

4.1 指针+-整数

4.2 指针-指针

4.3 指针的关系运算

五、指针和数组

六、二级指针

七、指针数组

总结


一、指针是什么

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

指针理解的2个要点:
1. 指针是内存中一个最小单元的编号,也就是地址
2. 平时口语中说的指针,通常指的是指针变量,是用来存放内存地址的变量

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

#include 

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 = #

要将&numnum的地址)保存到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 

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 

int main()
{
	int n = 0x11223344;

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

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

	return 0;
}

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

C语言初阶指针(对指针的初步了解)_第1张图片

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

C语言初阶指针(对指针的初步了解)_第2张图片

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

C语言初阶指针(对指针的初步了解)_第3张图片

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

三、野指针

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

3.1 野指针成因

1. 指针未初始化

#include

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

	return 0;
}

2. 指针越界访问

#include

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

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

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

	return 0;
}

3.2 如何规避野指针

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

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 

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 

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 

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 

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

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

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

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;
}


总结

本文是对指针的初步介绍,主要让我们在写代码的时候能够简单的使用指针

你可能感兴趣的:(C语言,c语言,c++)