C++入门编程四(指针、结构体、const修饰指针(深度理解))
文章目录
-
-
- 指针的基本概念
- 针所占内存空间
- 空指针和野指针
- const修饰指针
- 指针和数组
- 指针和函数
- 指针、数组、函数结合案例
- 结构体的定义和使用
- 结构体数组
- 结构体指针
- 结构体嵌套结构体
- 结构体做函数参数
- 结构体中 const使用场景
- 结构体案例
-
- 案例1
- 案例2
-
基于b站黑马c++视频做的笔记，仅供参考和复习！！！
指针的基本概念
指针的作用： 可以通过指针间接访问内存
指针中存放的数据是地址，通过地址即门牌号取址来找到对应的存储数据。
- 内存编号是从0开始记录的，一般用十六进制数字表示。
- 可以利用指针变量保存地址。
指针的进阶可以看看我的另一篇博文
// 1 定义指针
int a = 10;
//指针定义的语法： 数据类型 * 指针变量名；
int* p; //变量名叫p，类型为int *，即整数类型的指针
//char *q 代表字符类型的指针
//让指针记录变量a的地址
p = &a;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;
//2 使用指针
//可以通过解引用的方式来找到指针指向的内存
// 指针前加 * 代表解引用，找打指针指向的内存中的数据
*p = 100;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;
针所占内存空间
//指针所占内存空间
int a = 10;
int* p = &a;
cout << "sizeof (int *) = " << sizeof(p) << endl;
cout << "sizeof (int *) = " << sizeof(int *) << endl;
cout << "sizeof (float *) = " << sizeof(float *) << endl;
cout << "sizeof (double *) = " << sizeof(double *) << endl;
cout << "sizeof (char *) = " << sizeof(char *) << endl;
所有指针类型在32位操作系统下是4个字节，64位则是8个字节。
空指针和野指针
空指针：指针变量指向内存中编号为0的空间。用途：初始化指针变量。注意：空指针指向的内存是不可以访问的。
野指针：因为指针未被初始化，所以指针所指向的也是随机的，他是个野指针。
//空指针
//1 空指针用于给指针变量进行初始化
//int* p = NULL;
//2 空指针是不可以进行访问
//0~255之间的内存编号是系统占用的，因此不可访问
// *p = 100 是不可取的
//野指针
//在程序中，尽量避免出现野指针
int* p = (int*)0x1100; //避免直接指向非法的内存空间
cout << *p << endl;
// 空指针和野指针都不是我们申请的空间，因此不要进行访问。
const修饰指针
很多人难以理解const修饰指针的情况，下面我用图解的方式来帮助大家理解，这样很容易会记住
int a = 10;
int *p = &a;
首先定义一个指针，指针指向的int类型的变量a，如下图所示。指针p的指向是可以改变的，即此时指针可以通过赋值操作指向其他地方。
1、const int * p = &a，如图，const修饰的是int类型，即表明int a这个变量是不可以改变的，那么指针的指向不受影响，可以改变。
2、int* const p =&a，如图，const修饰的是指针，即表明指针指向的那个箭头是不可以改变的，对于int类型的变量a里的值就可以改变。
int a = 10;
int b = 20;
//常量指针
const int * p1 = &a;
//*p1 = 20; 错误
p1 = &b; //指针的指向可以修改
//指针常量
//特点： 指针的指向不可以修改，指针指向的值指可以改
int* const p2 = &b;
*p2 = 30; //指针指向的值可以改
//const即修饰指针和常量
//特点： 指针的指向和指针指向的值都不可以改
const int* const p3 = &a;
指针和数组
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "第一个元素为：" << arr[0] << endl;
int* p = arr; //arr就是数组地址
cout << "指针访问第一个元素为：" << *p << endl;
p++; //让指针向后偏移4个字节 p里面的地址++
cout << "指针访问第二个元素为：" << *p << endl;
cout << "利用指针遍历数组" << endl;
int* p1 = arr;
for (int i = 0; i < 10; i++){
cout << *p1 << endl;
p1++; //实质是 p1+1*sizeof（int）
}
指针和函数
void swap01(int a, int b)
{
int temp = a;
a = b;
b = temp;
}
void swap02(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
//指针和函数
//1 值传递
int a = 10;
int b = 20;
swap01(a, b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
//2 地址传递
int c = 10;
int d = 20;
swap02(&c, &d);//如果是地址传递，可以修改实参
cout << "c = " << c << endl;
cout << "d = " << d << endl;
system("pause");
return 0;
}
其中，地址传递时，首先系统分别位c，d开辟内存。而传入参数时，系统为p1和p2指针变量开辟空间，里面存放的时c和d的地址值。
指针、数组、函数结合案例
封装一个函数，利用冒泡排序，实现对整型数组的升序排序。例如数组：int arr[10] = { 4,3,6,9,1,2,10,8,7,5 }。
//冒泡排序函数 参数1 数字的首地址 参数2 数组长度
void bubbleSort(int *arr, int len)
{
for (int i = 0; i < len - 1; i++){
for (int j = 0; j < len - i - 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)
{
cout << "排序后---------------" << endl;
for (int i = 0; i < len; i++){
cout << arr[i] << " ";
}
}
int main()
{
int arr[10] = { 2,4,6,5,10,7,1,3,8,9 };
int* p = arr;
cout << "排序前---------------" << endl;
for(int i = 0; i< 10; i++){
cout << arr[i] << " ";
}
cout << endl;
//数组长度
int len = sizeof(arr) / sizeof(arr[0]);
bubbleSort(arr, len);
printArray(arr, len);
cout << endl;
return 0;
}
结构体的定义和使用
语法 struct 类型名称 {成员列表}；
//1 创建学生数据类型 结构体定义
//自定义数据类型，一些类型数据集合组成的一个类型
//语法 struct 类型名称 {成员列表}
struct Student
{
string name; //姓名
int age; //年龄
int score; //分数
}s3; //顺便创建结构体变量名
//2 通过学生类型创建具体学生 三种赋值方式
//2.1 struct Student s1
//结构体变量创建时struct关键字可以省略
Student s1;//结构体变量命名为s1
//成员赋值
s1.name = "张三";
s1.age = 18;
s1.score = 100;
cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
//2.2 struct Student s2 = {...}
struct Student s2 = { "李四", 20, 80 }; //struct可省略
cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;
//2.3 在定义结构体时顺便创建结构体变量
s3.name = "王五";
s3.age = 22;
s3.score = 70;
cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
结构体数组
struct Student
{
string name; //姓名
int age; //年龄
int score; //分数
};
//创建结构体数组
struct Student stuArray[3] =
{
{"张三", 18, 100}, //初始化赋值
{"李四", 20, 90},
{"王五", 22,80},
};
//给结构体数组中的元素赋值
stuArray[2].name = "赵六";
stuArray[2].age = 80;
//遍历结构体数组
for (int i = 0; i < 3; i++){
cout << "姓名：" << stuArray[i].name << " 年龄：" << stuArray[i].age << " 分数：" << stuArray[i].score << endl;
}
结构体指针
作用：通过指针访问结构体中的成员。利用操作符 -> 可以通过结构体指针访问结构体属性。
struct student * p = &s 定义结构体类型的指针 类比于int* p = &a。
//定义学生结构体
struct student
{
string name; //姓名
int age; //年龄
int score; //分数
};
//1 创建学生结构体变量
struct student s = { "张三", 18, 100 };
//2 通过指针指向结构体变量
struct student * p = &s;
//3 通过指针访问结构体变量中的数据
//通过结构体指针 访问结构体中的属性， 需要利用‘->’
cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
结构体嵌套结构体
//定义学生结构体
struct student
{
string name; //姓名
int age; //年龄
int score; //分数
};
//定义老师结构体
struct teacher
{
int id; //教师编号
string name; //教师姓名
int age; //年龄
struct student stu; //辅导学生
};
int main()
{
//结构体嵌套结构体
//创建老师
teacher t;
t.id = 10086;
t.name = "老王";
t.age = 60;
t.stu.name = "小王";
cout << "老师姓名：" << t.name << endl << "老师辅导的学生姓名：" << t.stu.name << endl;
system("pause");
return 0;
}
结构体做函数参数
总结：如果不想修改主函数中的数据，用值传递，反之用地址传递
//定义学生结构体
struct student
{
string name; //姓名
int age; //年龄
int score; //分数
};
//打印学生信息
//1 值传递
void printStudent1(struct student s1)
{
cout << "子函数中打印 姓名：" << s1.name << " 年龄 " << s1.age << " 分数 " << s1.score << endl;
}
//2 地址传递
void printStudent2(struct student *p)
{
p->name = "李四";
cout << "子函数中打印 姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
}
student s;//结构体变量命名
s.name = "张三";
s.age = 18;
s.score = 85;
printStudent1(s);
printStudent2(&s);
//cout << "main函数中打印 姓名：" << s.name << " 年龄 " << s.age << " 分数 " << s.score << endl;
结构体中 const使用场景
//定义学生结构体
struct student
{
string name; //姓名
int age; //年龄
int score; //分数
};
//将函数中的形参改为指针，可以减少内存空间，而且不会复制新的副本出来
void printStudent(const student *p)
{
//p->age = 100; //加入const之后，一旦修改就会报错，防止误操作
cout << "姓名：" << p->name << " 年龄 " << p->age << " 分数 " << p->score << endl;
}
int main()
{
struct student s = { "李四", 20, 80 };
printStudent(&s);
system("pause");
return 0;
}
结构体案例
案例1
学校正在做毕设项目，每名老师带领5个学生，总共有3名老师，需求如下：
设计学生和老师的结构体，其中在老师的结构体中，有老师姓名和一个存放5名学生的数组作为成员。学生的成员有姓名、考试分数，创建数组存放3名老师，通过函数给每个老师及所带的学生赋值。最终打印出老师数据以及老师所带的学生数据。
案例2
设计一个英雄的结构体，包括成员姓名，年龄，性别;创建结构体数组，数组中存放5名英雄。通过冒泡排序的算法，将数组中的英雄按照年龄进行升序排序，最终打印排序后的结果。
案例汇总地址可查看相应代码