C++学习笔记之结构体、内存分区模型、C++引用

最新推荐文章于 2022-10-06 15:26:20 发布

可别让我逮住你乐

最新推荐文章于 2022-10-06 15:26:20 发布

阅读量263

点赞数

分类专栏： C++ 文章标签： c++ 指针

本文链接：https://blog.csdn.net/weixin_46819249/article/details/109559693

版权

C++ 专栏收录该内容

19 篇文章 1 订阅

订阅专栏

一、结构体

1.结构体基本概念

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

2.结构体定义和使用

2.1结构体的定义

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

struct student
{
	//成员列表
	string name;	//姓名
	int age;		//年龄
	int score;		//分数
};

2.2通过结构体创建变量

方式有3种：

struct student s1;
struct student s2 ={ … };
在定义结构体时顺便创建结构体变量；

代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>
//1.结构体定义
struct student
{
	//成员列表
	string name;	//姓名
	int age;		//年龄
	int score;		//分数
}s3;		//2.3顺便创建结构体变量
int main()
{
	//2.通过学生类型创建具体学生

	//2.1 
	struct student s1; //创建结构体变量时struct 可以省略
	s1.name = "张三";	//给s1属性赋值，通过.访问结构体变量中的属性
	s1.age = 18;
	s1.score = 100;
	cout << "姓名：" << s1.name << "年龄：" << s1.age << "成绩：" << s1.score << endl;
	//2.2
	struct student s2 ={ "李四",19,80 };
	cout << "姓名：" << s2.name << "年龄：" << s2.age << "成绩：" << s2.score << endl;
	//2.3 在定义结构体时顺便创建结构体变量
	s3.name = "张三";	//给s1属性赋值，通过.访问结构体变量中的属性
	s3.age = 18;
	s3.score = 100;
	cout << "姓名：" << s3.name << "年龄：" << s3.age << "成绩：" << s3.score << endl;
}

3.结构体数组

作用：将自定义的结构体放入到数组中方便维护
语法：struct 结构体名数组名[ 元素个数 ] = { {},{},....{} };
代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>
//1.结构体定义
struct student
{
	//成员列表
	string name;	//姓名
	int age;		//年龄
	int score;		//分数
};		
int main()
{
	//2.创建结构体数组
	struct student stuArray[3] =
	{
		{"张三",18,100},
		{"李四",45,70},
		{"张三",18,100}
	};
	//3.给结构体数组中的元素赋值
	stuArray[2].name = "王五";
	stuArray[2].age = 50;
	stuArray[2].score = 60;
	//4.遍历结构体数组
	for (int i = 0; i < 3; i++)
	{
		cout << "姓名：" << stuArray[i].name
			<< "年龄：" << stuArray[i].age
			<< "分数：" << stuArray[i].score << endl;
	}
	return 0;
}

4.结构体指针

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

利用操作符 ->可以通过结构体指针访问结构体属性
代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>
//1.结构体定义
struct student
{
	//成员列表
	string name;	//姓名
	int age;		//年龄
	int score;		//分数
};		
int main()
{
	//2.创建结构体变量
	struct student s = {"张三",18,100};

	//3.通过指针指向结构体变量
	struct student* p = &s;

	//4.通过指针访问结构体变量中的数据
	cout << "姓名为：" << p->name<< endl
		<< "年龄为：" << p->age << endl
		<< "成绩为：" << p->score << endl ;
	
	return 0;
}

5.结构体嵌套结构体

代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>

//定义学生结构体
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 = 12212;
	t.age = 50;
	t.name = "老王";
	t.stu.name = "小王";
	t.stu.age = 15;
	t.stu.score = 60;
	cout << t.name << t.stu.name << endl;
	return 0;
}

6.结构体做函数参数

作用：将结构体作为参数向函数中传递
传递方式有2种：

值传递
地址传递
代码如下（示例）：

#include<iostream>
using namespace std;
#include<string>

//定义学生结构体
struct student
{
	//成员列表
	string name;	//姓名
	int age;		//年龄
	int score;		//分数
};
void printfstudent1(struct student stu1)
{
	stu1.age = 30;
	cout << "值传递中 姓名：" << stu1.name << " " << "年龄： " << stu1.age << " " << "成绩：" << stu1.score << endl;
}
void printfstudent2(struct student* p)
{
	p->age = 40;
	cout << "地址传递中 姓名：" << p->name << " " << "年龄： " << p->age << " " << "成绩：" << p->score << endl;
}
int main()
{

	student stu = { "张三" ,18,100 };
	//值传递
	printfstudent1(stu);
	cout << "主函数中 姓名：" << stu.name << " " << "年龄： " << stu.age << " " << "成绩：" << stu.score << endl;
	//地址传递
	printfstudent2(&stu);
	cout << "主函数中 姓名：" << stu.name << " " << "年龄： " << stu.age << " " << "成绩：" << stu.score << endl;
	return 0;
}

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

7. 结构体中const使用场景

作用：用const防止误操作

将函数中形参改为指针，可以减少内存空间，而且不会复制新的副本出来
用const struct xxxx *p;可以防止误操作
在函数中一旦有修改的操作就会报错

二、内存分区模型

1. C++程序在执行时，将内存大方向划分为4个区域：

代码区：存放函数体的二进制代码，由操作系统进行管理的
全局区：存放全局变量、静态变量、常量
栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

内存四区的意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

2.程序运行前

在程序编码后，生成了exe可执行文件，未执行该程序前分为两个区域：
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此
全局区还包括了常量区，字符串常量和其他常量也存放在此
该区域的数据在程序结束后由操作系统释放

3.程序运行后

栈区

由编译器自动分配释放，存放函数的参数值，局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

int* func() //形参数据也会放在栈区
{
	int a = 10;	//局部变量  存放在栈区，栈区的数据在函数执行完后自动释放
	return &a;		//返回局部变量的地址
}

int main()
{
	
	int* p = func();
	cout << *p << endl;	//10 第一次可以打印正确的数字，是因为编译器做了保留
	cout << *p << endl;	//2077534608(乱码了）	第二次这个数据就不再保留了

	return 0;
}

堆区

由程序员分配释放，若程序员不释放，程序结束时由操作系统回收,可以控制堆区存放数据的生命周期
在C++中主要利用new在堆区开辟内存

int* func()
{
	//利用new关键字 可以把数据开辟到堆区
	//指针 本质也是局部变量，放在栈上，指针保存的数据是放在堆区
	int* p = new int(10);	//10是存放的数据
	return p;		
}

int main()
{
	//在堆区开辟数据
	int* p = func();
	cout << *p << endl;		//10
	cout << *p << endl;		//10

	return 0;
}

4. new运算符

c++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new 数据类型
利用new创建的数据，会返回该数据对应的类型的指针

示例1：基本语法

int* func()
{
	//1.利用new关键字 在堆区创建整型数据
	//new 返回的是 该数据类型的指针
	int* p = new int(10);	//10是存放的数据
	return p;		
}
int main()
{
	//在堆区开辟数据
	int* p = func();
	cout << *p << endl;		//10
	cout << *p << endl;		//10
	//堆区的数据 由程序员管理开辟，程序员管理释放
	//如果想释放堆区的数据，利用关键字 delete
	delete	p;
	//cout << *p <<endl; //内存已经被释放，再次访问就是非法操作，会报错

	return 0;
}

示例2.开辟数组

//2.在堆区利用new开辟数组
void test02()
{	
	//创建10个整型数据的数组，在堆区
	int* arr = new int[10]; //这里的10代表数组有10个元素
	for (int i = 0; i < 10; i++)
	{
		arr[i] = i + 100;//赋值
		
	}
	for (int i = 0; i < 10; i++)
	{
		cout << arr[i] << endl;

	}
	//释放堆区数组
	//释放堆区数组的时候 要加[]才可以
	delete[] arr;
}
int main()
{
	test02();
	return 0;
}

总结：释放堆区数组的时候，要加 [ ] 才可以；

三、c++中的引用

1.引用的基本使用

作用：给变量起别名
语法：数据结构 &别名 = 原名

代码如下（示例）：

int main()
{
	int a=10;
	int& b = a;
	cout << a << endl;	//10
	cout << b << endl;	//10
	b = 100;
	cout << a << endl;	//100	
	cout << b << endl;	//100	
	return 0;
}

2.引用注意事项

引用必须初始化
引用在初始化后，不可改变

代码如下（示例）：

int main()
{
	int a=10;
	//int &b;错误，引用必须初始化
	int& b = a;//一旦初始化后就不可改变
	cout << a << endl;	//10
	cout << b << endl;	//10
	int c = 20;
	b = c;  //赋值操作，而不是更改引用
	cout << a << endl;	//20
	cout << b << endl;	//20	
	cout << c << endl;	//20
	return 0;
}

3.引用做函数返回值

作用：引用是可以作为函数的返回值存在的

注意：不要返回局部变量引用
用法：函数调用作为左值

代码如下（示例）：

//返回局部变量引用
int& test01()
{
	int a = 10;	//局部变量
	return a;
}
//返回静态变量引用
int& test02()
{
	static int a = 20;	//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}
int main()
{
	//不能返回局部变量的引用
	int& ref = test01();
	cout << "ref= " << ref << endl;	//10
	cout << "ref= " << ref << endl;	//2048043408（乱码了）

	//如果函数做左值，那么必须返回引用
	int& ref2 = test02();
	cout << "ref2 = " << ref2 << endl;	//20
	cout << "ref2 = " << ref2 << endl;	//20

	test02() = 1000;
	cout << "ref2 = " << ref2 << endl;	//1000
	cout << "ref2 = " << ref2 << endl;	//1000
	return 0;
}

4.引用的本质

实质：引用的本质在c++内部实现是一个指针常量（指向是不可以修改的，指向的值可以修改）

代码如下（示例）：

//发现是引用，转换为 int* const ref = &a;
void func(int& ref)
{
	ref = 100;	//ref是引用，转换为*ref = 100
}
int main()
{
	int a = 10;
	//自动转换为 int* const ref = &a;
	int& ref = a;
	ref = 20;	//内部发现ref是引用，自动帮我们转换为 *ref = 20;
	cout << "a:" << a << endl;	//20
	cout << "ref:" << ref << endl;	//20
	func(a);

	return 0;
}

结论：c++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了

5.常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参表中，可以加const修饰形参，防止形参改变实参

代码如下（示例）：

//引用使用的场景，通常用来修饰形参
void showValue(const int &ret)
{
	cout << ret << endl;	//20
}
int main()
{
	//int& ref = 10; 引用本身需要一个合法的内存空间，因此这行错误

	//加入const之后，编译器将代码修改为int temp = 10;const int & ref = temp;
	const int& ref = 10;	
	//ref =20；//加入const之后变为只读，不可以修改

	//函数中利用常量引用防止误操作修改实参
	int a = 20;
	showValue(a);		
	cout << a << endl;	//20
	return 0;

}