（1）指针、结构体

小小白-小落

已于 2023-10-09 15:13:25 修改

阅读量65

点赞数

分类专栏： C++学习文章标签： c++

于 2023-05-04 15:28:03 首次发布

本文链接：https://blog.csdn.net/weixin_52542873/article/details/130464243

版权

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

22 篇文章 0 订阅

订阅专栏

本文详细介绍了C++中的指针概念，包括指针的定义、作用，指针所占内存空间，空指针和野指针的区分，以及如何使用const修饰指针。此外，还讲解了指针在访问数组、函数参数传递以及结构体中的应用，包括结构体的定义、使用、数组、指针和嵌套结构体。最后，通过两个案例展示了结构体在实际问题中的应用。

摘要由CSDN通过智能技术生成

指针

指针的定义和使用

指针作用：可以通过指针间接访问内存

内存编号是从0开始记录的，一般用十六进制数字表示，可以利用指针变量保存地址

通过指针保存一个地址，简单来说，指针就是一个地址

int a = 10;
//定义指针  数据类型 * 指针变量名
int * p;
p = &a;//指针记录变量a的地址
cout << "a的地址：" << &a << endl;
cout << "指针p：" << p << endl;
//使用指针
*p = 1000;//指针前加 * 代表解引用，找到指针指向的内存中的数据
cout << "a = " << a << endl;// 输出a = 1000
cout << "*p = " << *p << endl;// 输出*p = 1000

指针所占内存空间

指针：不论什么数据类型，32位操作系统下，占用4个字节空间；64位操作系统下，占用8个字节空间

int a = 10;
int * p = &a;
cout << "sizeof(int *) = " << sizeof(int *) << endl;// 输出4
cout << "sizeof(int *) = " << sizeof(p) << endl;// 输出4

空指针和野指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注：空指针指向的内存是不可以访问的

int * p = NULL;//NULL代表空
//内存编号0~255为系统占用内存，不允许用户访问

野指针：指针变量指向非法的内存空间

int * p = (int *)0x1100;//指向内存编号为0x1100的空间
cout << *p << endl;//运行报错

空指针和野指针都不是我们申请的空间，因此不要访问

const修饰指针

三种情况：

const修饰指针——常量指针

const修饰常量——指针常量

const既修饰指针又修饰常量

int a = 10;
int b = 10;
const int * p = &a;//常量指针：指针指向的值不可以改，指针的指向可以改
*p = 20;//此处运行会出错，指针指向的值不可以改
p = &b;//此处正确

int * const p2 = &a;//指针常量：指针指向的值可以改，指针的指向不可以改
*p2 = 100;//此处正确
p2 = &b;//此处运行会出错，指针的指向不可以改

const int * const p3 = &a;//const修饰指针和变量：指针指向的值和指针的指向都不可以改
*p3 = 100;//此处运行会出错，指针指向的值不可以改
p3 = &b;//此处运行会出错，指针的指向不可以改

技巧：看const右侧紧紧跟着的是指针还是常量，是指针就是常量指针，是常量就是指针常量

指针和数组

利用指针访问数组中元素

int arr[] = {1,2,3,4,5,6,7,8,9,10};
int * p = arr;//指向数组的指针，arr就是数组首地址
cout << "利用指针访问第一个元素：" << *p << endl;//输出 1
p++;
cout << "利用指针访问第二个元素：" << *p << endl;//输出 2
//利用指针遍历数组,即输出数组中所有元素
int * p2 = arr;
for(int i = 0; i < 10; i++)
{
   cout << *p2 << endl;
   p2++;
}

指针和函数

利用指针做函数参数，可修改实参的值

地址传递

void swap(int *p1, int *p2)
{
   int temp = *p;
   *p1 = *p2;
   *p2 = temp;
}
int main()
{
   int a = 10;
   int b = 20;
   swap(&a,&b);
   cout << "a = " << a << endl;//输出为20
   cout << "b = " << b << endl;//输出为10

}

如果不想改变实参，就用值传递，如果想改变实参，就用地址传递

指针数组函数案例：

冒泡排序

封装一个函数，利用冒泡排序，实现对整型数组的升序排序。int arr[10] = {4,3,6,9,1,2,10,8,7,5}

void bubbleSort(int * arr, int len)
{
   for(int i = 0; i < len - 1; i++)
   {
      for(int j = 0; j < len - 1; j++)
      {
         if(arr[j] > arr[j + 1])
         {
            int temp = arr[j];
            arr[j] = arr[j + 1];
            arr[j + 1] = temp;
         }
      }
   }
}
void printArray(int * arr, int len)
{
   for(int i = 0; i < len; i++)
   {
      cout << arr[i] <<endl;
   }
}
int main()
{
int arr[10] = {4,3,6,9,1,2,10,8,7,5};//创建数组
int len = sizeof(arr) / sizeof(arr[0]);//数组长度
bubbleSort(arr, len);//创建函数，实现冒泡排序
printArray(arr, len);//打印排序后的数组
return 0;
}

结构体

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

定义和使用

语法：struct 结构体名 {结构体成员列表}；

通过结构体创建变量的方式有三种：

struct 结构体名变量名
struct 结构体名变量名 = {成员1值，成员2值……}
定义结构体时顺便创建变量

//创建结构体，一些类型集合组成的一个类型
struct Student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
}s3;//顺便创建变量s3
int main()
{
	//结构体变量创建时，可省略struct
	struct Student s1;//方式1
	s1.name = "123";
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << " 年龄：" << s1.age << "分数：" << s1.score << endl;
	struct Student s2 = { "456",19,80 };//方式2
	cout << "姓名：" << s2.name << " 年龄：" << s2.age << "分数：" << s2.score << endl;
	s3.name = "789";
	s3.age = 20;
	s3.score = 60;
	cout << "姓名：" << s3.name << " 年龄：" << s3.age << "分数：" << s3.score << endl;
}

结构体数组

将自定义的结构体放入到数组中方便维护

语法：struct 结构体名数组名[元素个数] = { {}，{}，……}

struct Student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
};
int main()
{
	struct Student stuArray[3] =
	{
		{"123",18,100},{"456",28,99},{"789",38,66}
	};
	//也可后期赋值
    stuArray[2].name = "四五六";
	stuArray[2].age = 18;
	stuArray[2].score = 80;
	//遍历结构体数组
    for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArray[i].name << "年龄：" << stuArray[i].age << "分数：" << stuArray[i].score << endl;
	}
}

结构体指针

通过指针访问结构体中的成员

利用操作符 -> 可以通过结构体指针访问结构体属性

struct Student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
};
int main()
{
	struct Student s = { "123",18,100 };//创建结构体变量
	struct Student * p = &s;//通过指针指向结构体变量
	cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
	//通过指针访问结构体中数据
}

结构体嵌套结构体

结构体中的成员可以是另一个结构体

例：每个老师辅导一个学员，一个老师的结构体中，记录一个学生的结构体

struct student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
};
struct teacher
{
	int id;//教师编号
	string name;
	int age;
	struct student stu;//学生结构体
};
int main()
{
	teacher t;//创建老师
	t.id = 10000;//赋值
	t.name = "丽丽";
	t.age = 50;
	t.stu.name = "七七";
	t.stu.age = 20;
	t.stu.score = 60;
}

在结构体中可以定义另一个结构体作为成员，用来解决实际问题

结构体做函数参数

将结构体作为参数向函数中传递

传递方式：值传递；地址传递。

struct student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
};
void printStudent1(struct student s)
{
	s.age = 100;
	cout << "值传递 姓名：" << s.name << " 年龄：" << s.age << "分数：" << s.score << endl;
}
void printStudent2(struct student * p)
{
	p->age = 200;
	cout << "地址传递 姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
}
int main()
{
	struct student s;//实参
	s.name = "123"; s.age = 20; s.score = 80;
	printStudent1(s);
	printStudent2(&s);
	cout << "main函数中打印 姓名：" << s.name << " 年龄：" << s.age << "分数：" << s.score << endl;
}

如果不想修改主函数中的数据，用值传递，反之用地址传递

结构体中const使用场景

用const防止误操作

struct student
{
	string name;//用string，记得加 #include<string>
	int age;
	int score;
};
//将形参改为指针，可减少内存空间的占用，且不会复制新的副本
void printStudents(const student *s)
{
	//s->age = 100;地址传递时形参改变会影响实参，加入const将其变为只读，有修改的操作就会报错
	cout << "姓名：" << s->name << " 年龄：" << s->age << "分数：" << s->score << endl;
}
int main()
{
	struct student s = { "123",15,70 };
	printStudents(&s);
}

结构体案例

案例一：

学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求：设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员，学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值，最终打印出老师数据以及老师所带的学生数据。

//定义学生结构体
struct Student
{
	string sName;//用string，记得加 #include<string>
	int score;
};
struct Teacher  //定义老师结构体
{
	string tName;
	struct Student sArray[5];//学生数组
};
void allocateSpace(struct Teacher tArray[],int len)//给老师和学生赋值
{
	string nameSeed = "ABCDE";
	for (int i = 0; i < len; i++)//老师赋值
	{
		tArray[i].tName = "Teacher_";
		tArray[i].tName += nameSeed[i];
		for (int j = 0; j < 5; j++)//给每名老师带的学生赋值
		{
			tArray[i].sArray[j].sName = "Student_";
			tArray[i].sArray[j].sName += nameSeed[j];
			int random = rand() % 61 + 40;//40~100随机
			tArray[i].sArray[j].score = random;
		}
	}
}
void printInfo(struct Teacher tArray[], int len)//打印所有信息
{
	for (int i = 0; i < len; i++)
	{
		cout << "老师姓名：" << tArray[i].tName << endl;
		for (int j = 0; j < 5; j++)
		{
			cout << "\t学生姓名：" << tArray[i].sArray[j].sName << " 考试分数：" << tArray[i].sArray[j].score << endl;
		}
	}
}
int main()
{
	srand((unsigned int)time(NULL));//随机数种子，记得加 #include<ctime>
	struct Teacher tArray[3];//3名老师数组
	int len = sizeof(tArray) / sizeof(tArray[0]);//计算数组长度，以防之后人数产生变化
	allocateSpace(tArray, len);
	printInfo(tArray, len);
}

案例二：

设计一个英雄的结构体，包括成员姓名，年龄，性别；创建结构体数组，数组中存放5名英雄。通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。

struct Hero
{
	string name;
	int age;
	string sex;
};
void bubbleSort(struct Hero heroArray[], int len)//冒泡排序
{
	for (int i = 0; i < len - 1; i++)
	{
		for (int j = 0; j < len - 1; j++)
		{
			if (heroArray[j].age > heroArray[j + 1].age)
			{
				struct Hero temp = heroArray[j];
				heroArray[j] = heroArray[j + 1];
				heroArray[j + 1] = temp;
			}
		}
	}
}
void printHero(struct Hero heroArray[], int len)//打印
{
	for (int i = 0; i < len; i++)
	{
		cout << " 姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age << " 性别：" << heroArray[i].sex << endl;
	}
}
int main()
{
	struct Hero heroArray[5] =
	{
		{"刘备",23,"男"},
		{"关羽",22,"男"},
		{"张飞",20,"男"},
		{"赵云",21,"男"},
		{"貂蝉",19,"女"},
	};
	int len = sizeof(heroArray) / sizeof(heroArray[0]);
	cout << "排序前：" << endl;
	for (int i = 0; i < len; i++)
	{
		cout << " 姓名：" << heroArray[i].name << " 年龄：" << heroArray[i].age << " 性别：" << heroArray[i].sex << endl;
	}
	bubbleSort(heroArray, len);
	cout << "排序后：" << endl;
	printHero(heroArray, len);
}