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

最新推荐文章于 2023-12-04 23:48:47 发布
最新推荐文章于 2023-12-04 23:48:47 发布
阅读量301 收藏 1
点赞数
分类专栏： C++ 文章标签： c++ 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46819249/article/details/109559693
版权

文章目录

一、结构体

1.结构体基本概念

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

2.结构体定义和使用

2.1结构体的定义

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

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

2.2通过结构体创建变量

方式有3种：

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

代码如下（示例）：

#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;

}
可别让我逮住你乐
关注
专栏目录
C++面试题之结构体内存对齐计算问题总结大全
12-31
本文给大家介绍的是关于C++结构体内存对齐计算的相关内容，内存对齐计算可谓是笔试题的必考题，但是如何按照计算原则算出正确答案一开始也不是很容易的事，所以专门通过例子来复习下关于结构体内存对齐的计算问题。...
【C/C++】结构体&内存对齐
花想云的博客
11-12 1929
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
C++ 内存空间总结
houxian1103的博客
10-04 827
因为结构体有时候需要字节对齐。一般而言，struct 的 sizeof 是所有成员字节对齐后长度相加，而 union 的 sizeof 是取最大的成员长度。在默认情况下，编译器为每一个变量或数据单元按其自然对界条件分配空间。一般地，可以通过下面的方法来改变默认的对界条件：(1) 使用伪指令#pragma pack(n)，C编译器将按照n个字节对齐。(2) 使用伪指令#pragma pack()，取消自定义字节对齐方式。
c++ 内存结构
AlbertHMY的博客
12-16 1232
c++ STL笔记C/C++ 内存结构C++内存结构分类全局变量，全局函数普通类的内存模型类成员非静态成员内存对齐的原则：确定对齐单位：填充内存：静态成员成员函数非静态成员函数静态成员函数补充&总结 C/C++ 内存结构 C++内存结构分类 全局变量，全局函数 static字符不影响全局变量和函数在内存中的表现形式，唯一区别是加了static修饰的值外部不可见。 全局函数都位于代码段，全局变量根据其是否赋有初值，是否被const修饰区分： 未被const修饰，赋初值：位于读写数据段； 未被con
C/C++结构体内存对齐
mrqiuwen的博客
10-06 2069
C/C++结构体内存对齐原理的详细解释，详细介绍对齐规则，并利用一些示例进行讲解
C++基础总结系列之【内存结构】
存星的博客
03-19 1872
目录 内存分区 内存图 内存四区 栈区 堆区 数据区 代码区 堆与栈的区别 动态内存管理 malloc、calloc、realloc new/delete new和malloc的区别 智能指针 内存对齐 what why 没有内存对齐机制 引入内存对齐机制 how 对齐系数 有效对齐值（对齐单位） 结构体内存对齐规则 类内存对齐规则 常见的内存错误（如何避免内存泄漏） 内存分区 内存图 内存四区 栈区 作用：保存局部变量、函数调用参数
408结构体对齐-typedef-结构体指针-c++引用
最新发布
07-07
### 结构体对齐、typedef、结构体指针与C++引用详解 #### 一、结构体对齐 **结构体对齐**是指在结构体中的成员变量在内存中的排列方式，这种排列是为了提高CPU访问内存的速度。由于现代处理器的设计倾向于以一定的...
千锋教育C++Markdown学习笔记
08-01
在C++中，`const`修饰的变量存储在不同的内存区域，如常量区或栈区，并且拥有不同的访问规则。 ## 引用 1. **引用的概念**：引用类似于指针，但使用起来更像别名。引用在声明时必须初始化，并且初始化后不能改变。...
c++学习笔记.pdf
07-12
3. 结构体内存对齐是C++中为了提高内存存取效率而采取的一种内存分配策略。编译器会根据处理器的存取方式和数据类型自动插入填充字节，以确保数据对齐。这可以提高数据存取的效率，但也可能会导致内存的额外消耗。 ...
c++ 结构体的嵌套使用
hanxiaoqiag的专栏
03-24 6378
c++ 结构体的嵌套使用
C++中结构体占内存空间大小的判断
12-22
1、功能： 　　申明一个结构体，在以下四种情况下判断其占有的内存空间的大小； 　　2、程序及其代码 　　2.1 大化对其原则 　　代码一：结构体中不包含字符串变量的时候； // 结构体占内存空间的判断.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include "String.h" #include "iostream" using namespace std;   int _tmain(int argc， _TCHAR* argv[]) {  typedef struct STUDENT_INFO  
C++ 类和结构体所占内存大小
changyang208的专栏
11-29 3326
类所占内存：   类所占内存的大小是由成员变量（静态变量除外）决定的，成员函数（这是笼统的说，后面会细说）是不计算在内的。 摘抄部分： 成员函数还是以一般的函数一样的存在。a.fun()是通过fun(a.this)来调用的。所谓成员函数只是在名义上是类里的。其实成员函数的大小不在类的对象里面，同一个类的多个对象共享函数代码。而我们访问类的成员函数是通过类里面的一个指针实现，
C/C++中的内存对齐问题
DayDayUp
12-06 541
内存对齐的三条规则 数据成员对齐规则，结构体(struct)(或联合(union))的数据成员，第一个数据成员存放在offset为0的地方，以后每个数据成员存储的起始位置要从该成员大小或者成员的子成员(只要该成员有子成员，比如数组、结构体等)大小的整数倍开始(如：int 在 64bit 目标平台下占用 4Byte，则要从4的整数倍地址开始存储) 结构体作为成员，如果一个结构体里有某些结构体成员，则结构体成员要从其内部最大元素大小的整数倍地址开始存储 结构体的总大小，即sizeof的结果，必须是其内部最大成
C++结构体内存对齐
Rainbow
11-07 293
结构体的大小并不是简单地将每个结构体成员的大小相加就能得到。cpu一次能读取多少内存要看数据总线是多少位，如果是16位，则一次只能读取2个字节，如果是32位，则可以读取4个字节，并且cpu不能跨内存区间访问。三个原则：1、第一个成员的首地址为0.2、每个成员的首地址是自身大小的整数倍3、结构体的总大小，为其成员中所含最大类型的整数倍。
C/C++ 结构体、类的内存对齐规则，以及#pragma pack、alignas、alignof的用法。
weixin_44078346的博客
12-04 1375
接下来在64位系统中、编译器默认的对齐字节。
c语言之自定义类型
Leetp
03-07 648
union enum struct 结构体内存对齐
C++中类与结构体所占内存分析
qq_41696018的博客
08-17 1089
我们知道C++中不同类型数据占不同字节的，具体见下表： 数据类型 32位 64位 char 1 1 int 4 4 float 4 8 double 8 8 那么对于一个结构体或类占多少字节呢？ 我们首先定义一个类： class people { public: int age_p; double weight_p; char name[5]; }; 机灵的小伙伴可能一口说出这个类所占的字节...
一文读懂C/C++ 结构体内存分配原则
baihebeijixing的专栏
02-26 1509
C语言struct结构体极大的扩充了数据类型，其实就相当于C++中的类，C++为了保存对C的兼容也保留了结构体这个数据类型，不过一般C++中结构体都只有数据没有方法。 但是C/C++中结构体在内存中的大小是如何确定的呢？ 其实 结构体在内存中的大小由以下两个规则确定; 1、当前总大小是下一个数据类型的整数倍（如果不满足则补齐，但是单字节最大补齐4/8位具体由当前所有单字节数据类型中最大的数据...
C++ 结构体 内存分配
leexurui的专栏
08-29 838
C/C++类/结构体内存遵循三个原则：      c++中结构跟类几乎相同，除了默认成员的访问控制不同。以下结构体的内存对齐在类class中也是一样的。   1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除； 2) 结构体每个成员相对于结构体首地址的偏移量（offset）都是成员自身大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）； 3)
C++ Primer学习笔记：结构体与sizeof解析
"这篇学习笔记主要涵盖了C++ Primer的多个核心概念和技术，包括结构体、内存管理、数据类型对齐、标准输入输出、容器、泛型编程、面向对象编程、模板、异常处理、运行时类型识别以及一些特殊的语言特性。笔记深入浅...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值