标题
- 一.指针
- 1.指针的定义和使用
- 2.指针所占的内存空间
- 3.空指针与野指针
- 4.const修饰指针
- 5.指针和数组
- 6.指针和函数
- 二.结构体
- 1.结构体的定义与使用
- 2.结构体数组
- 3.结构体指针
- 4.结构体的嵌套使用
- 5.结构体做函数参数
- 6.结构体中const使用场景
- 7.案例练习
一.指针
- 作用: 可以通过指针间接的访问一段内存
- 内存编号是从0开始记录的,一般用16进制的数字表示
- 可以利用指针变量保存地址
1.指针的定义和使用
- 定义
指针类型 指针名;(指针类型指int *,float *等等) - 使用:可以通过解引用的方法
*来操作指针所指向的内存
#include <iostream>
using namespace std;
int main() {
int a = 12;
// 定义指针： 数据类型 * 指针名；
int * p;
p = &a; // &为取地址符号,可以取到a的地址
cout << "&a = " << &a << endl;
cout << " p = " << p << endl; // 二者打印的内容相同,均为变量a的地址
// 使用指针
*p = 12345; // *代表解引用,可以通过它找到指针指向的内存中的数据
cout << "*p = " << *p << endl;
cout << " a = " << a << endl; // 修改*p的值也间接的修改了变量a的值
system("pause");
return 0;
}
2.指针所占的内存空间
- 32位系统:不管什么类型的指针都占用4个字节空间
- 64位:8字节
可以在这里调整编译器编译时的32或64位选项
int a = 99;
int* p = &a;
// 具体输出和操作系统有关
cout << "sizeof(int *) = " << sizeof(p) << endl;
cout << "sizeof(bool *) = " << sizeof(bool *) << endl;
cout << "sizeof(char *) = " << sizeof(char *) << endl;
cout << "sizeof(double *) = " << sizeof(double *) << endl;
cout << "sizeof(long long *) = " << sizeof(long long *) << endl;
3.空指针与野指针
- 空指针:指向的内存编号为0的指针
用途:不知道指针的具体赋值时,进行指针的初始化
注意:空指针指向的内存是不可以被访问的!!!(0~255之间的内存编号是系统占用的,不能被访问)
这段代码在编写的时候没有问题,但是在编译运行的时候会报异常
#include <iostream>
using namespace std;
int main() {
int* p = NULL;
int a = *p;
system("pause");
return 0;
}
- 野指针:指针变量指向了非法的内存空间
int * p = (int *)0x1100;
// 这里会报访问权限异常,因为这个地址就不是由你本人申请的!
int c = *p;
空指针与野指针,都不是我们申请的空间,请不要随意的访问它!!!!
4.const修饰指针
- const修饰指针有三种情况:
1.const修饰指针—常量指针
2.const修饰常量—指针常量
3.const即修饰指针也修饰常量
5.指针和数组
- 可以利用指针访问数组内的元素
int arr[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
int* p = arr; // 将这个指针指向数组的首地址
cout << "指针访问第一个元素：" << *p << endl; // 输出0
/*
// 如果需要用指针来访问第二个元素，需要让指针指向后移4个字节
p++; // 自增已经可以让指针向后移动4字节
cout << "第二个元素: " << *p << endl; // 输出1
*/
// 利用指针遍历数组元素
for (int i = 0; i < size(arr); i++) {
cout << "arr[" << i << "] = " << *p << endl;
cout << "p = " << p << endl;
cout << "&arr[" << i << "] = " << &arr[i] << endl;
p++;
}
6.指针和函数
- 利用指针作为函数的参数, 通过解引用可以修改实参的值!
#include <iostream>
using namespace std;
void swap01(int* a, int* b);
// 值传递,并不会改变传入的形参的值
void swap02(int a, int b) {
int temp = a;
a = b;
b = temp;
}
int main() {
int a = 33;
int b = 99;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "值传递" << endl;
swap02(a, b);
// 不会改变传入的实参的值
cout << "a = " << a << endl; // 33
cout << "b = " << b << endl; // 99
cout << "地址传递" << endl;
swap01(&a, &b);
// 可以看到这里的值已经被改变了
cout << "a = " << a << endl; // 99
cout << "b = " << b << endl; // 33
system("pause");
return 0;
}
// 交换两个数的函数, 通过解引用的方式交换两个数
void swap01(int* a, int* b) { // 把房间号传递过来了,可以借助房间号,改变房间里放的东西
int temp = *a;
*a = *b;
*b = temp;
}
案例描述:实现一个函数,利用冒泡排序对整数数组进行降序排序
#include <iostream>
using namespace std;
// 输出数组内容
void printArray(int* arr, int size) {
for (int i = 0; i < size; i++) {
cout << arr[i] << "\t";
}
cout << endl;
}
// 冒泡排序
void bubbleSort(int* arr, int size) {
for (int i = 0; i < size - 1; i++) {
for (int j = 0; j < size - 1 - i; j++) {
if (arr[j] < arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main() {
int arr[] = { 9, 34, 56, 7, 123, 45, 67, 98, 33, 12, 55, 987, 11, -2 };
int* arrP = arr; // arr就是数组的首地址
bubbleSort(arr, size(arr));
printArray(arr, size(arr));
system("pause");
return 0;
}
二.结构体
- 结构体属于用户自定义的数据类型, 允许用户存储不同的数据类型
1.结构体的定义与使用
- 语法
struct 结构体名 { 结构体成员列表 }; - 通过结构体创建变量(使用结构体)的方式有三种:
1.struct 结构体名 变量名;
2.struct 结构体名 变量名 = { 成员值1, 成员值2... };
3.定义结构体是顺便创建变量
#include <iostream>
using namespace std;
// 定义结构体
struct Student {
string name;
int age;
double score;
} s0; // 创建结构体的时候顺便创建结构变量(不推荐)
void printStudent(Student stu) {
cout << "name: " << stu.name << " age: " << stu.age << " score: " << stu.score << endl;
}
int main() {
// 这种方式struct关键字能省略不写
struct Student s1;
s1.name = "叶子";
s1.age = 18;
s1.score = 100;
printStudent(s1);
// 按顺序填入结构体数据
Student s2 = { "老黄", 25, 60 };
printStudent(s2);
// 创建的时候顺便创建的量
s0.name = "YeZi";
s0.age = 25;
s0.score = 100;
printStudent(s0);
system("pause");
return 0;
}
2.结构体数组
- 将自定义的结构体放入数组中方便维护
- 语法
struct 结构体名 数组名[元素个数] = { {} , {}, ... {} }
#include <iostream>
using namespace std;
struct Student {
// 成员列表
string name; // 姓名
int age; // 年龄
int score; // 分数
};
int main() {
// 结构体数组
Student stus[3] = {
{"叶子", 18, 100},
{"老黄", 20, 99},
{"罗磊", 21, 100}
};
// 遍历结构体数组
for (int i = 0; i < size(stus); i++) {
cout << "姓名:" << stus[i].name
<< " 年龄:" << stus[i].age
<< " 分数:" << stus[i].score << endl;
}
system("pause");
return 0;
}
3.结构体指针
- 通过指针来访问结构体的元素
- 利用操作符
->可以通过结构体指针访问结构体的属性
#include <iostream>
using namespace std;
struct Student {
// 成员列表
string name; // 姓名
int age; // 年龄
int score; // 分数
};
int main() {
Student stu0 = { "老黄", 20, 99 };
// 指针指向结构体变量
Student* p = &stu0;
// 通过指针访问结构体变量中的数据
cout << "姓名: " << p->name << " 年龄: " << p->age << " 分数: " << p->score << endl;
system("pause");
return 0;
}
4.结构体的嵌套使用
- 结构体也可以结合实际情况嵌套使用
#include <iostream>
using namespace std;
struct Student {
// 成员列表
string name; // 姓名
int age; // 年龄
int score; // 分数
};
struct Teacher {
string name;
int age;
Student stu;
};
int main() {
Teacher teacher = {"娟", 18, {"叶子", 18, 100}};
cout << "老师姓名: " << teacher.name << " 老师年龄: " << teacher.age
<< " 学生姓名: " << teacher.stu.name << " 学生年龄: " << teacher.stu.age << " 学生分数: " << teacher.stu.score << endl;
system("pause");
return 0;
}
5.结构体做函数参数
- 将结构体作为参数向函数中传递
- 方式有两种：
值传递
地址传递（形参修改影响实参的值）
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
double score;
};
// 输出函数，值传递不影响实参变量
void printStudent(Student stu, string tag) {
cout <<"tag: " << tag << " name: " << stu.name << " age : " << stu.age << " score : " << stu.score << endl;
}
// 值传递，在函数中修改结构体不会影响具体值
void printStudent1(Student stu) {
stu.name = "luilui";
stu.age = 20;
stu.score = 99;
printStudent(stu, "printStudent1");
}
// 引用传递，函数中修改结构体会影响实参的值
void printStudent2(Student* ps) {
ps -> name = "老黄";
ps -> age = 20;
ps -> score = 99;
printStudent(*ps, "printStudent2");
}
int main() {
Student stu;
stu.name = "叶子";
stu.age = 18;
stu.score = 100;
cout << "值传递: " << endl;
printStudent(stu, "main");
printStudent1(stu);
printStudent(stu, "main"); // 函数里修改了具体的值，但是值传递不影响实参结构体
cout << "\n\n引用传递: " << endl;
printStudent(stu, "main");
printStudent2(&stu); // 取地址符，传入的是对应结构体的指针
printStudent(stu, "main"); // 引用传递，函数里边的修改影响实参结构体
system("pause");
return 0;
}
6.结构体中const使用场景
- 作用： 用const来防止误操作(可以结合前文中的常量指针进行理解)
示例：
#include <iostream>
using namespace std;
struct Student {
string name;
int age;
double score;
};
// 3值传递时,会将实参复制给形参,数据量越大,占用的内存越多
void printStruct(Student stu) {
cout << "name: " << stu.name << " age: " << stu.age << " score: " << stu.score << endl;
}
// 4将函数中的形参改为指针,不会复制,所以会介绍内存空间的占用
void printStruct(const Student *stu) { // 6加入const(常量指针)可以防止在形参修改,影响到实参的值
// 5这样会留下一个隐患,地址传递时对形参指针的修改会影响到实参的值
// stu->name = "老黄"; 7加入const之后会报错,防止误操作
cout << "name: " << stu->name << " age: " << stu->age << " score: " << stu->score << endl;
}
int main() {
//1创建结构体变量
Student s = { "叶子", 18, 100.00 };
//2通过函数打印结构体的信息
printStruct(s);
printStruct(&s);
system("pause");
return 0;
}
7.案例练习
- 案例1:
#include <iostream>
using namespace std;
struct Student {
string name;
int score;
};
struct Teacher {
string name;
Student stus[5];
};
void input(Teacher* tchs, int sizeT) {
for (int i = 0; i < sizeT; i++) {
string name = "";
cout << "请输入第" << i << "位老师的姓名:";
cin >> name;
tchs[i].name = name;
cout << "开始录入 " << name << " 老师的学生们!" << endl;
for (int j = 0; j < size(tchs[i].stus); j++) {
string name = "";
cout << "输入学生" << j << "的姓名:";
cin >> name;
tchs[i].stus[j].name = name;
cout << "输入 " << name << " 的成绩:" << endl;
int score = 0;
cin >> score;
tchs[i].stus[j].score = score;
}
}
}
void input1(Teacher tchs[], int sizeT) {
for (int i = 0; i < sizeT; i++) {
string name = "";
cout << "请输入第" << i << "位老师的姓名:";
cin >> name;
tchs[i].name = name;
cout << "开始录入 " << name << " 老师的学生们!" << endl;
for (int j = 0; j < size(tchs[i].stus); j++) {
string name = "";
cout << "输入学生" << j << "的姓名:";
cin >> name;
tchs[i].stus[j].name = name;
cout << "输入 " << name << " 的成绩:" << endl;
int score = 0;
cin >> score;
tchs[i].stus[j].score = score;
}
}
}
void print(Teacher* tchs, int sizeT) {
for (int i = 0; i < sizeT; i++) {
cout << tchs[i].name << " 老师的学生信息:" << endl;
for (int j = 0; j < size(tchs[i].stus); j++) {
string name = "";
cout << tchs[i].stus[j].name << " 的成绩是: " << tchs[i].stus[j].score << endl;
}
}
}
int main() {
Teacher teachers[3];
input(teachers, size(teachers));
print(teachers, size(teachers));
system("pause");
return 0;
}
- 案例2
#include<iostream>
#include<ctime>
using namespace std;
/*
设计一个英雄的结构体，包括成员 姓名，年龄，性别
创建结构体数组，数组中存放5名英雄。
通过冒泡排序法将数组中的英雄按照年龄进行升序排序，打印最终结果。
*/
// 英雄结构体
struct Hero {
string name;
int age;
string sex;
};
// 随机获取英雄的年龄
int getRandAge() {
int age = rand() % 51;
if (age <= 21) { // 小于201岁重新获取
return getRandAge();
}
return age;
}
// 初始化英雄数据
void initHeroInfo(Hero heros[], int len) {
srand((unsigned int)time(NULL));
heros[0] = { "刘备", getRandAge(), "男"};
heros[1] = { "关羽", getRandAge(), "男" };
heros[2] = { "张飞", getRandAge(), "男" };
heros[3] = { "赵云", getRandAge(), "男" };
heros[4] = { "貂蝉", getRandAge(), "女" };
heros[5] = { "西施", getRandAge(), "女" };
}
// 冒泡排序
void sortHeros(Hero *heros, int len) {
for (int i = 0; i < len - 1; i++) {
for (int j = 0; j < len - i - 1; j++) {
if (heros[j].age > heros[j + 1].age) {
Hero temp = heros[j];
heros[j] = heros[j + 1];
heros[j + 1] = temp;
}
}
}
}
// 打印英雄信息
void printHeros(const Hero *heros, int len) {
for (int i = 0; i < len; i++) {
cout << "姓名: " << heros[i].name << " 年龄: " << heros[i].age << " 性别: " << heros[i].sex << endl;
}
cout << endl;
}
int main() {
Hero heros[6];
initHeroInfo(heros, size(heros));
printHeros(heros, size(heros));
sortHeros(heros, size(heros));
printHeros(heros, size(heros));
system("pause");
return 0;
}
学习笔记与课程计划
B站视频链接
![[Linux]进程等待](https://img-blog.csdnimg.cn/b0f651abc48d4f19bad26d1b288bb730.png)
