深入理解指针（指针数组、数组指针、结构体指针、二级指针）

小谢%同学

已于 2023-02-17 09:01:01 修改

阅读量832

点赞数 4

分类专栏： C++学习文章标签： c++ 开发语言

于 2023-01-24 13:35:00 首次发布

本文链接：https://blog.csdn.net/weixin_65743593/article/details/128596474

版权

C++学习专栏收录该内容

36 篇文章 2 订阅

订阅专栏

指针的概念

在计算机科学中，指针（Pointer）是编程语言中的一个对象，利用地址，它的值直接指向（points to）存在电脑存储器中另一个地方的值。由于通过地址能找到所需的变量单元，可以说，地址指向该变量单元。因此，将地址形象化的称为“指针”。意思是通过它能找到以它为地址的内存单元。

指针变量

1. 指针变量的定义和使用

指针变量的定义，形如：数据类型* 指针名=&变量；

指针变量的使用，取地址运算符&；例如&i为取变量i的地址；

解引用运算符*：与&为逆运算，取地址所存储的内容；例如pi=&i；*pi取得是i的内容；

例如

int i=1024;    //普通变量
int* pi=&i;    //声明一个整型指针变量，指向i的地址
cout<<"i="<<*pi<<endl;    //通过取址符，获取指针指向的内容

2. 指针的类型

int* i;    //整型指针变量
float* f;    //浮点型指针变量
char* ch;    //字符型指针变量

指针的运算

1. 指针的增减运算

指针变量的增减指的是向前或者向后移动若干个单位（单位长度与指针的类型有关）

例如：

int main()
{
	int a = 10;
	int* pa = &a;
	printf("%p\n", pa);
	printf("%p\n", pa + 1);
	char* pc = (char*)&a;
	printf("%p\n", pc);
	printf("%p\n", pc + 1);
	system("pause");
	return 0;
}

指针的步长和指针类型有关

2. 指针和指针之间的加减运算

前提是两个指针指向同一个空间

指针减指针得到的是两个指针之间的元素个数

例如：

int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	cout << &arr[8] - &arr[2] << endl;
    return 0;
}

野指针

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

形成的原因

1. 使用已经释放过的指针

指针被free或者delete后了，却没有将其置为NULL。free和delete函数只是将指针所指向的内存释放掉了，是内存称为自由内存，但是并没有把指针本身的内容清除掉，所以指针仍指向已经释放的动态内存，这是非法访问。

例如：

#include<stdio.h>
#include<stdlib.h>
void func(int* p)
{
	printf("%d\n", p);
	free(p);
}
int main()
{
	int* arr = (int*)malloc(sizeof(int) * 5);
	for (int i = 0; i < 5; i++)
	{
		arr[i] = i;
	}
	func(arr);
	printf("%d\n", arr);
	system("pause");
	return 0;
}

2. 指针访问越界

即在变量的作用范围之外使用了指向变量地址的指针。这一般发生在将调用函数中的局部变量的地址传出来引起的。这点容易被忽略，虽然代码是很可能可以执行无误，然而却是极其危险的。在执行指针的++操作时候，容易发生指针访问越界，访问到不该访问的内存空间。

例如：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
void func(char* p)
{
	printf("s\n", p);
	free(p);
	p = NULL;
}
int main()
{
	int arr[10] = { 0,1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	for (int i = 0; i <= 10; i++)
	{
		printf("arr[%d]=%d\n", i, *p);
		p++;
	}
	system("pause");
	return 0;
}

3. 指针未初始化

任何指针变量被刚创建时不会被自动初始化为NULL指针。所以，指针变量在创建的同时应当被初始化分配内存（使用malloc函数、calloc函数或new操作符），要么将指针设置为NULL，要么让它指向合法的内存。

例如：

#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

int main()
{
	int a = 10;
	int* pa = &a;
	int* p;
	*p = 20;
	system("pause");
	return 0;
}

如何规避野指针

1. 定义指针时，同时初始化为NULL

2. 在指针解引用之前，先去判断这个指针是不是NIULL

3. 指针使用完之后，将其赋值为NULL

4. 在指针使用之前，将其赋值绑定给一个可用地址空间

数组指针和指针数组的区别

详见数组指针和指针数组的区别

指针与一维数组

#include<iostream>
using namespace std;
int main()
{
	int arr[5] = { 1,2,3,4,5 };
	int* p = arr;
	cout << "数组名的地址" << arr << endl;
	cout << "数组首元素的地址" << &arr[0] << endl;
	cout << "数组第二个元素的地址" << &arr[1] << endl;
	for (int i = 0; i < 5; i++)
	{
		cout << *(p + i) << "," << arr[i] << endl;
	}
	system("pause");
	return 0;
}

结论:

数组名表示的是数组首元素的地址;

p+i 其实计算的是数组 arr 下标为i的地址,解引用就是其存储的值；

指针与二维数组

#include<iostream>
using namespace std;
int main()
{
	int arr[3][4] = { {1,2,6,4},{5,9,7,1},{9,1,2,12} };
	int* p1 = arr[0];	//p指针指向二维数组第一行的地址
	int* p2 = arr[1];
	cout << "二维数组的地址：" << arr << endl;
	cout << "二维数组首行的地址：" << arr[0] << endl;
	cout << "二维数组首行首元素的地址：" << &arr[0][0] << endl;
	cout << "二维数组首行第二个元素的地址：" << &arr[0][2] << endl;
	cout << "二维数组第二行首元素的地址：" << &arr[1][0] << endl;
	//访问第一行数据
	for (int i = 0; i < 4; i++)
	{
		cout << arr[0][i] << " ";
	}
	cout << endl;
	//利用指针访问第一行数据
	for (int i = 0; i < 4; i++)
	{
		cout << *(p1 + i) << " ";
	}
	cout << endl;
	for (int i = 0; i < 4; i++)
	{
		cout << *(p2 + i) << " ";
	}
	cout << endl;
	for (int i = 0; i < 4; i++)
	{
		cout << *(arr[2] + i )<<" ";
	}
	cout << endl;
    //利用和指针访问整个二维数组
    int a[3][4] = { {1,2,3,4},{5,6,7,8},{9,10,11,12} };
	int(*p)[4] = a;
	for (int i = 0; i < 3; i++)
	{
		for (int j = 0; j < 4; j++)
		{
			printf("%2d ", *(*(a + i) + j));
		}
		printf("\n");
	}
	system("pause");
	return 0;
}

结论：

数组名的地址表示的是二位数组首行首元素的地址

补充！！！

二维数组的行地址和各个元素地址的表示

int a[3][4];
a;//代表数组首行地址，一般用a[0][0]的地址表示
&a;//代表整个数组的地址，一般用a[0][0]地址表示
a[i];//代表了第i行起始元素的地址
&a[i];代表了第i行的地址，一般用a[i][0]的地址表示
a[i]+j;//代表了第i行第j个元素地址,a[i]就是j==0的情况
a[i][j];//代表了第i行第j个元素
&a[i][j];//代表了第i行第j个元素的地址

数组名与指针的关系

a;//代表数组首行地址，一般用a[0][0]的地址表示
&a;//代表整个数组的地址，一般用a[0][0]地址表示
a[i];代表了第i行起始元素的地址(网上说是代表了第i行的地址，但我觉得不是，在讲数组与指针的关系时我会验证给大家看)
&a[i];代表了第i行的地址，一般用a[i][0]的地址表示
a[i]+j;//代表了第i行第j个元素地址,a[i]就是j==0的情况
a[i][j];//代表了第i行第j个元素
&a[i][j];//代表了第i行第j个元素的地址
*a;//代表数组a首元素地址也就是a[0]或者&a[0][0]
*(a+i);//代表了第i行首元素的地址,*a是i=0的情况
*(a+i)+j;//代表了第i行j个元素的地址
**a;//代表a的首元素的值也就是a[0][0]
*(*(a+i)+j);//代表了第i行第j个元素

结构体指针

#include<iostream>
using namespace std;
typedef struct
{
	int s_id;
	char name[10];
	int age;
} STU;
int main()
{
	STU stu_1;
	STU stu_3;
	STU* stu_2=&stu_3;
	stu_1.age = 18;
	stu_2->age = 20;
	stu_1.s_id = 1;
	(*stu_2).s_id = 2;
	strcpy(stu_1.name, "张三");
	strcpy(stu_2->name, "李四");
	cout << stu_1.name << endl;
	system("pause");
	return 0;
}

结构体数组的指针

如何访问结构体数组的指针

#include<iostream>
using namespace std;
typedef struct
{
	int s_id;
	char name[10];
	int age;
} STU;
int main()
{
	STU stu[3];
	STU* p1 = &stu[0];
	p1->age = 18;
	p1->s_id = 1;
	strcpy(p1->name, "张三");
	cout <<p1->age << endl;
	system("pause");
	return 0;
}

二级指针

指针变量也是变量，所以指针变量也有地址，叫二级指针。

int i=10;
int* pi=&i;
int** ppi=&pi;

int i=10;
int** ppi=&&i;
//！！！切记不能这样（因为&i运算完是i相对应的地址，
//是一个常量，常量变量才有地址，所以&常量是错误的。

二级指针的运算

举个栗子

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int* pa = &a;
	int** ppa = &pa;
	cout << "ppa=" << ppa << endl;
	cout << "pa=" << *ppa << endl;
	cout << "*ppa=" << pa << endl;
	cout << "**ppa=" << **ppa << endl;
	cout << "*pa=" << **ppa << endl;
	cout << "a=" << a << endl;
	system("pause");
	return 0;
}

指针与函数

指针为参数

例如之前学C语言时交换两个值，
#include<stdio.h>
void swap(int* a, int* b)
{
	int t = *a;
	*a = *b;
	*b = t;
}
void main()
{
    int a=1,b=2;
    swap(&a,&b);
    printf("a=%d,b=%d\n",a,b);
}
指针传递其实也是一种值传递，只不过传递的是地址值，如果通过该地址取*解引用，是可以改变形参指针的原值的，但如果只是指针的值发生变化的话，并不会影响实参指针及其原值。

返回为指针

#include<stdio.h>
int* func(int a, int b)
{
	int target = a * b;
	return &target;
}
void main()
{
	int a = 10, b = 20;
	int* r = func(a, b);
	printf("target=%d\n", *r);
}
注意！！！

用指针作为函数返回值时需要注意的一点是，函数运行结束后会销毁在它内部定义的所有局部数据，包括局部变量、局部数组和形式参数，函数返回的指针请尽量不要指向这些数据，C语言没有任何机制来保证这些数据会一直有效，它们在后续使用过程中可能会引发运行时错误。请看下面的例子：
#include <stdio.h>
int *func(){
    int n = 100;
    return &n;
}
int main(){
    int *p = func(), n;
    n = *p;
    printf("value = %d\n", n);
    return 0;
}
运行结果：
value=100；
n 是 func() 内部的局部变量，func() 返回了指向 n 的指针，根据上面的观点，func() 运行结束后 n 将被销毁，使用 *p 应该获取不到 n 的值。但是从运行结果来看，我们的推理好像是错误的，func() 运行结束后 *p 依然可以获取局部变量 n 的值，这个上面的观点不是相悖吗？
为了进一步看清问题的本质，不妨将上面的代码稍作修改，在第9~10行之间增加一个函数调用，看看会有什么效果：
#include <stdio.h>

int *func(){
    int n = 100;
    return &n;
}

int main(){
    int *p = func(), n;
    printf("c.biancheng.net\n");
    n = *p;
    printf("value = %d\n", n);
    return 0;
}
运行结果：
c.biancheng.net
value = -2
可以看到，现在 p 指向的数据已经不是原来 n 的值了，它变成了一个毫无意义的甚至有些怪异的值。与前面的代码相比，该段代码仅仅是在 *p 之前增加了一个函数调用，这一细节的不同却导致运行结果有天壤之别，究竟是为什么呢？
前面我们说函数运行结束后会销毁所有的局部数据，这个观点并没错，大部分C语言教材也都强调了这一点。但是，这里所谓的销毁并不是将局部数据所占用的内存全部抹掉，而是程序放弃对它的使用权限，弃之不理，后面的代码可以随意使用这块内存。对于上面的两个例子，func() 运行结束后 n 的内存依然保持原样，值还是 100，如果使用及时也能够得到正确的数据，如果有其它函数被调用就会覆盖这块内存，得到的数据就失去了意义。

指向函数的指针

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include<stdlib.h>
//返回两个数中较大的一个
int max(int a, int b) {
    return a > b ? a : b;
}

int main() {
    int x, y, maxval;
    //定义函数指针
    int (*pmax)(int, int) = max;  //也可以写作int (*pmax)(int a, int b)
    printf("Input two numbers:");
    scanf("%d %d", &x, &y);
    maxval = (*pmax)(x, y);
    printf("Max value: %d\n", maxval);
    system("pause");
    return 0;
}

对函数进行了调用。pmax 是一个函数指针，在前面加 * 就表示对它指向的函数进行调用。注意( )的优先级高于*，第一个括号不能省略。

void类型指针

void*表示一个“不知道什么类型"的指针，只表示一个地址，不知道时多少字节的数据单位。

void*是一块不能动的地址

voi指针赋值给其他类型的指针时都要进行转换
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<stdlib.h>
int main()
{
	int a = 10;
	int* p1 = &a;
	void* p2=p1;
	int* p3 = (int*)p2;
	p2 = p1;
	printf("%d\n", *p1);
	printf("%d\n", p2);
	printf("%d\n", *p3);
	system("pause");
	return 0;
}