本文详细介绍了C++程序运行时内存的四个主要区域：代码区、全局区、栈区和堆区，以及new操作符在堆区动态分配内存的作用。此外，还探讨了引用的概念，包括其基本使用、注意事项和在函数参数及返回值中的应用。同时，讲解了函数的默认参数、占位参数和重载，以及类和对象的封装概念。
目录
目录
1 内存分区模型
c++程序在执行时，将内存大方向划分为“4个区域”
- 代码区：存放函数体的二进制代码，由操作系统进行管理的
- 全局区：存放全局变量和静态变量以及常量
- 栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
- 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
1.1 程序运行前
在程序编译后,生成了EXE（exe）可执行程序，为执行该程序前分为两个区域
代码区：
存放CPU执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量形成对比。
全局区还包含了常量区，字符串常量和其他常量也存放在此。
该区域的数据在程序结束后由操作系统释放。
实例：
#include<iostream>
using namespace std;
//c - const g - global l - local
//全局变量
int g_a = 10;
int g_b = 10;
//const修饰ide全局变量，全局常量
const int c_g_a = 10;
const int c_g_b = 10;
int main()
{
//全局区
//创建普通局部变量
int a=10;
int b=10;
cout <<"局部变量a 的地址为: "<<(int)&a << endl;
cout <<"局部变量b 的地址为: "<<(int)&b << endl;
//静态变量 在普通变量面前加static ，属于静态变量
static int s_a = 10;
static int s_b = 10;
cout <<"静态变量s_a 的地址为： "<< (int)&s_a << endl;
cout <<"静态变量s_b的地址为： "<< (int)&s_b << endl;
//常量
//字符串常量
cout << "字符串常量的地址为: " << (int)&"hello world" << endl;
//const 修饰的变量
//const修饰的全局变量，const修饰的局部变量
//全局常量 - 全局变量
cout << "全局常量 c_g_a 的地址为:" <<(int)&c_g_a << endl;
cout << "全局常量 c_g_b 的地址为:" <<(int)&c_g_b << endl;
//局部变量
const int c_l_a = 10;
const int c_l_b = 10;
cout << "局部常量 c_g_a的地址为:" <<(int)&c_l_a << endl;
cout << "局部常量 c_g_b 的地址为:" <<(int)&c_l_b << endl;
system("pause");
return 0;
}1.2 程序运行后
栈区：
由编译器自动分配释放，存放函数的参数值，局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
实例：
#include<bits/stdc++.h>
using namespace std;
//栈区数据注意事项
//栈区的数据由编译器管理开辟和释放
int* func(int b) //形参数据也会放在栈区
{
b = 100;
int a= 10;//局部变量 存放在栈区，栈区的数据在函数执行完后自动给释放
return &a; //返回局部变量的地址
}
int main()
{
//接受func函数的返回值
int * p = func(1);
cout << *p << endl;//第一次可以打印正确的数字，是因为编译器做了保留
cout << *p << endl;//第二次出问题
system("pause");
return 0;
} 堆区：
由程序员分配释放，若程序员不释放，程序结束时由操作系统回收
在C++中主要利用new在堆区开辟内存
实例:
#include<bits/stdc++.h>
using namespace std;
int * func()
{
//利用new关键字 可以将数据开辟到堆区
//指针本质就是一个局部变量，放在栈上，指针保存的数据是放在堆区
int * p = new int(10);
return p;
}
int main()
{
//在堆区开辟数据
int *p = func();
cout << *p << endl;
return 0;
} 1.3 new 操作符
C++中利用new操作符在堆区开辟数据
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符delete
语法：new + 数据类型
利用new 创建的数据，会返回该数据对应的类型的指针
实例：
#include<bits/stdc++.h>
using namespace std;
//1、new的基本语法
int * func()
{
//在堆区创建整型数据
//new返回是 该数据类型的指针
int * p = new int(10);
return p;
}
void test01()
{
int * p = func();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
//堆区的数据 由程序员管理开辟、管理释放
//可以用delete 来进行释放
delete p;
cout << *p << endl;//内存已经被释放，再次访问是非法操作，会报错
}
//2、在堆区利用new开辟数组
void test02()
{
//创建10个整型数据的数组，在堆区
int * arr = new int[10];//10 -》 代表数组有10个元素
for(int i = 0 ;i < 10 ;i ++)
{
arr[i] = i + 100;//给10个元素赋值
}
for(int i = 0 ; i < 10 ; i++)
{
cout << arr[i] << " " << endl;
}
//释放堆区数组
//释放数组的时候 要加[] 才可以
delete[] arr;
}
int main()
{
test01();
test02();
return 0;
}2 引用
2.1 引用的基本使用
作用：给变量起别名
语法： 数据类型 * 别名 = 原名
实例：
#include<bits/stdc++.h>
using namespace std;
int main()
{
//引用基本语法
//数据类型 &别名 = 原名
int a = 10;
//创建引用
int &b = a;
cout << " a = " << a << endl;
cout << " b = " << b << endl;
b =100 ;
cout << " a = " << a << endl;
cout << " b = " << b << endl;
return 0;
} 2.2 引用的注意事项
· 引用必须初始化。
·引用在初始化后，不可以改变。
实例：
#include<bits/stdc++.h>
using namespace std;
int main()
{
int a= 10 ;
// · 引用必须初始化。
// int &b;//错误的
int &b = a; //对的
// ·引用在初始化后，不可以改变。
int c= 20;
b = c;//赋值操作，而不是更改引用
cout << "a = " << a << endl;
cout << "b = " << b << endl;
cout << "c = " << c << endl;
return 0;
}2.3 引用做函数参数
- 作用：函数传参时，可以利用引用的技术让形参修饰实参
- 优点：可以简化指针修改实参。
实例：
#include<bits/stdc++.h>
using namespace std;
//交换函数
//1、值传递
void mySwap01(int a,int b)
{
int temp = a ;
a = b;
b = temp;
}
//2、地址传递
void mySwap02(int *a,int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
//3、引用传递
void mySwap03(int &a,int &b)
{
int temp =a ;
a = b;
b = temp ;
}
int main()
{
int a =10 ;
int b = 20 ;
// mySwap01(a,b); //值传递，形参不会修饰实参
// mySwap02(&a,&b); //地址传递，形参会修饰实参的
// mySwap03(a,b); //引用传递，形参会修饰实参的
cout <<"a = " << a << endl;
cout <<"b = " << b << endl;
return 0;
}
2.4 引用做函数返回值类型
实例:
#include<bits/stdc++.h>
using namespace std;
//引用做函数的返回值
//1、不要返回局部变量的引用
int &test01()
{
int a= 10;//局部变量存放在四区中的 栈区
return a;
}
//2、函数的调用可以作为左值
int &test02()
{
static int a =10 ; //静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
return a;
}
int main()
{
int &ref = test01();
cout <<"ref = " << ref << endl;//第一次结果正确，是因为编译器做了保留
cout <<"ref = " << ref << endl;//第二次结果错误，因为a的内存已经释放了
//2、函数的调用可以作为左值
int &ref2 = test02();
cout <<"ref = " << ref2 << endl;//第一次结果正确，是因为编译器做了保留
cout <<"ref = " << ref2 << endl;
test02() = 1000;//如果函数的返回值是引用，这个函数调用可以作为左值
cout <<"ref = " << ref2 << endl;//第一次结果正确，是因为编译器做了保留
cout <<"ref = " << ref2 << endl;
return 0;
}2.5 引用的本质
本质： 引用的本质在C++内部实现是一个指针常量
实例:
#include<bits/stdc++.h>
using namespace std;
//发现是引用，转换为 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;
cout <<"ref:" << ref << endl;
func(a);
return 0;
}2.6 常量引用
作用： 常量引用主要是用来修饰形参，防止误操作
实例:
#include<bits/stdc++.h>
using namespace std;
//打印数据函数
void showValue(const int &val)
{
// val = 10000; //有了const 后 不可以修改 val 保证val 不被修改
cout <<"val = " << val << endl;
}
int main()
{
//常量引用
//使用场景，用来修饰形参，防止误操作
//int a =10;
//加上const 之后，编译器将代码修改 int temp = 10;const int &ref = temp;
const int &ref = 10; //引用必须引一块合法的内存空间
//ref = 20; //加入const 之后变为只读，不可以修改
int a = 100;
showValue(a);
return 0;
}3 函数提高
3.1 函数默认参数
语法： 返回值类型 函数名 ( 参数 = 默认值 ) { }
实例:
#include<bits/stdc++.h>
using namespace std;
//函数默认参数
//如果我们自己传入数据，就用自己的数据，如果没有，那么就用默认值
//语法： 返回值类型 函数值 （形参 = 默认值） {}
int func(int a= 20, int b= 30,int c = 50)
{
return a + b + c;
}
//注意事项
//1、如果某个位置已经有了默认参数，那么从这个位置往后，从左到右都必须有默认值
/*int func2(int a, int b, int c)
{
return a + b + c;
}*/
//2、如果函数声明有默认参数，函数实现就不能有默认参数
// 声明与实现只能有一个默认参数
int func2(int a =1, int b = 1)
{
return a + b;
}
int main()
{
cout <<func(10,80) << endl;
cout << func2() << endl;
return 0;
}3.2 函数占位参数
C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
语法: 返回值类型 函数名 （数据类型） { }
实例：
#include<bits/stdc++.h>
using namespace std;
//占位参数
//返回值类型 函数名 （ 数据类型） {}
//目前阶段的占位参数 我们还用不到，后面会用到
//占位参数 还可以有默认参数
void func(int a, int )
{
cout << "this is func :" << endl;
}
int main()
{
func(10,10);//占位参数必须填补
return 0;
}3.3 函数重载
3.3.1 函数重载概述
作用： 函数名可以相同，提高复用性
函数重载满足条件：
- 同一个作用域下
- 函数名称相同
- 函数参数类型不同 或者 个数不同 或者 顺序不同
注意： 函数的返回值不可以作为函数重载的条件
实例：
#include<bits/stdc++.h>
using namespace std;
//函数重载
// 可以让函数名相同，提高复用性
//函数重载满足条件：
//1、同一个作用域下
//2、函数名称相同
//3、函数参数类型不同 或者 个数不同 或者 顺序不同
void func()
{
cout <<"func 的调用" << endl;
}
void func(int a)
{
cout <<"func(int a) 的调用" << endl;
}
void func(double b)
{
cout <<"func(double b) 的调用" << endl;
}
void func(double b,int a)
{
cout <<"func(double b) 的调用" << endl;
}
//注意事项
//函数的返回值不可以作为函数重载的条件
int func(double b,int a)
{
cout <<"func(double b) 的调用" << endl;
}
void func(double b,double c)
{
cout <<"func(double b) 的调用" << endl;
}
int main()
{
func();
func(10);
func(3.14);
func(1, 3);
func(3.13 , 10);
func(3.123 , 3.123);
return 0;
}3.3.2 函数重载注意事项
- 引用作为重载条件
- 函数重载碰到函数默认参数
实例：
#include<bits/stdc++.h>
using namespace std;
//函数重载的注意事项
//1、引用作为重载条件
void fun(int &a)// int &a = 10 不合法的
{
cout << "func(int &a) 调用" << endl;
}
void fun(const int &a)//const int &a =10; 合法
{
cout << "func(const int &a) 调用" << endl;
}
//2、函数重载碰到函数默认参数
void fun2(int a)
{
cout <<"func2(int a) 的调用 " << endl;
}
void fun2(int a,int b)
{
cout <<"func2(int a) 的调用 " << endl;
}
int main()
{
int a =10;
fun(a); // int &a
fun(10); //const int &a
fun2(3);//当函数重载碰到默认参数，出现二义性，报错，尽量避免这种情况
return 0;
}4 类和对象
C++面对对象的三大特征为：封装、继承、多态
C++认为万事万物都皆为对象，对象上有其属性和行为
4.1封装
4.1.1 封装的意义
封装是C++面对对象的三个特征之一
意义：
- 将属性和行为作为一个整体，表现生活中的事物
- 将属性和行为加为权限控制
封装意义一：
在设计类的时候，属性和行为写在一起，表现事物
语法：class 类名{ 访问权限 ： 属性 / 行为 } ；
实例:
#include<bits/stdc++.h>
using namespace std;
//设计一个圆类，求圆的周长
//圆求周长的公式: 2*PI*半径
//class 代表设计一个类，类后面紧跟着的就是类名称
class Circle
{
//访问权限
//公共权限
public:
//属性
//半径
int m_r;
//行为
//获取圆的行为
double calculateZC()
{
return 2*PI* m_r;
}
};
int main()
{
//通过圆类 创建具体的圆(对象)
//实例化 （通过一个类来创建一个对象的过程）
Circle c1;
//给圆的对象 的属性进行赋值
c1.m_r = 10;
//2*PI* 10 = 62.8
cout << "圆的周长为： " << c1.calculateZC() << endl;
return 0;
}实例2：
#include<bits/stdc++.h>
using namespace std;
//设计一个学生类，属性有姓名和学号。
//可以给姓名和学号赋值，可以显示学生的姓名和学号
//设计学生类
class Student
{
public://公共权限
//类中的属性和行为 我门统一称为 成员
//属性 成员属性 成员变量
//行为 成员函数 成员方法
//属性
string m_Name; //姓名
int m_Id; //学号
//行为
//显示姓名和学号
void showStudent()
{
cout << "姓名: " << m_Name <<"\t"<< "学号: " << m_Id << endl;
}
//给姓名赋值
void setName(string name)
{
m_Name = name;
}
//给学号赋值
void setId(int id)
{
m_Id = id;
}
};
int main()
{
//创建一个具体的学生
//实例化对象
Student s1;
//给s1对象 进行属性赋值操作
// s1.m_Name = "张三";
s1.setName("崔靖烨");
// s1.m_Id = 1;
s1.setId(1);
//显示学生信息
s1.showStudent();
Student s2;
s2.m_Name = "崔靖烨";
s2.m_Id = 3;
s2.showStudent();
return 0;
}封装意义二：
类在设计时，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
- public 公共权限
- protected 保护权限
- private 私有权限
实例：
#include<bits/stdc++.h>
using namespace std;
//访问权限
//三种
//public 公共权限 类内可以访问 类外可以访问
//protected 保护权限 类内可以访问 类外不可以访问 儿子可以访问父亲中的保护内容
//private 私有权限 类内可以访问 类外不可以访问 儿子不可以访问父亲的私有内容
class Person
{
public:
//公共权限
string m_Name; //姓名
protected:
//保护权限
string m_Car; //汽车
private:
//私有权限
int m_Password; //银行卡密码
public:
void func()
{
m_Name = "张三；
m_Car = "拖拉机";
m_Password = 123456;
}
};
int main()
{
//实例化一个具体的对象
Person p1;
p1.m_Name = "李四";
// p1.m_Car = "奔驰"; //保护权限内容，在类外访问不到
//p1.m_Password = 123; //私有权限内容，类外访问不到
p1.func();
return 0;
}4.1.2 struct 和 class 区别
在C++中struct 和 class区别
实例:
#include<bits/stdc++.h>
using namespace std;
class C1
{
int m_A;//默认权限 是私有
};
struct C2
{
int m_A; //默认权限 是公共
};
int main()
{
//struct 和 class 区别
//struct 默认权限是 公共 public
//class 默认权限是 私有 private
C1 c1;
//c1.m_A = 100; //在class 默认权限 私有，因此类外不可以访问
C2 c2;
c2.m_A = 100; // 在struct 默认权限 公共，因此可以访问
return 0;
}4.1.3 成员属性设置
扫一扫
500
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
