- 前言
- 一、内存分区模型
- 二、引用
- 三、函数提高
- 四、类和对象
- 五、文件操作
- 总结
前言
视频看的是bilibili的黑马程序员的视频，链接：
https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=14698314130453798526&spm_id_from=333.337.0.0
文字部分为手打，可能有部分小错误，欢迎批评指正。
一、内存分区模型
1 C++程序在执行时，将内存大方向划分为4个区域
- 代码区：存放函数体的二进制代码，由操作系统进行管理的
- 全局区：存放全局变量和静态变量以及常量
- 栈区：由编译器自动分配释放, 存放函数的参数值,局部变量等
- 堆区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收
2 在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域
代码区：
存放 CPU 执行的机器指令
代码区是共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
全局变量和静态变量存放在此.
全局区还包含了常量区, 字符串常量和其他常量（const修饰的全局常量）也存放在此.
该区域的数据在程序结束后由操作系统释放
//c-const g-global l-local
//全局变量
int g_a = 10;
int g_b = 10;
//全局常量
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;
cout << "全局变量g_a地址为： " << (int)&g_a << endl;
cout << "全局变量g_b地址为： " << (int)&g_b << endl;
//静态变量
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;
cout << "字符串常量地址为： " << (int)&"hello world1" << endl;
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_l_a地址为： " << (int)&c_l_a << endl;
cout << "局部常量c_l_b地址为： " << (int)&c_l_b << endl;
system("pause");
return 0;
}
3 栈区
由编译器自动分配释放, 存放函数的参数值,局部变量等
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放，再用指针操纵这块内存就属于非法操作了。
形参数据也会放在栈区
int * func()
{
int a = 10;
return &a;
}
int main() {
int *p = func();
cout << *p << endl; //第一次可以打印正确的数字，是因为编译器做了保留
cout << *p << endl; //第二次这个数据就不再保留了
system("pause");
return 0;
}
4 堆区
由程序员分配释放，若程序员不释放，程序结束后由操作系统回收
在C++中主要利用new在堆区开辟内存
int* func()
{
int* a = new int(10);
return a;
}
int main() {
int *p = func();
cout << *p << endl;
cout << *p << endl;
system("pause");
return 0;
}
5 指针本质也是局部变量，放在栈上，指针保存的数据是放在堆区。
6 new操作符语法
new 数据类型（数据值）
如：
int* a = new int(10);
new返回是该数据类型的指针
7 如果想释放堆区的数据，利用关键字“delete”
如：
int* a = new int(10); delete a;
8 在堆区利用new开辟数组
int* arr new int[10]; //10代表数组有10个元素 delete[] arr; //释放堆区的数组，释放数组的时候比释放一个元素多一个“[]”二、引用
1 引用的作用：给变量起别名
语法：数据类型 &别名 = 原名
别名和原名的数据类型是一样的。
2 引用的注意事项
引用必须要初始化
int &b; //是错误的
引用在初始化之后不可以改变
3 函数传参时，可以利用引用让形参修饰实参，可以简化指针修饰实参
如实现交换函数
//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);
cout << "a:" << a << " b:" << b << endl;
mySwap02(&a, &b);
cout << "a:" << a << " b:" << b << endl;
mySwap03(a, b);
cout << "a:" << a << " b:" << b << endl;
system("pause");
return 0;
}
4 引用可以作为函数的返回值存在，但是不要返回局部变量引用。
函数的调用可以作为左值
//返回局部变量引用
int& test01() {
int a = 10; //局部变量
return a;
}
//返回静态变量引用
int& test02() {
static int a = 20;
return a;
}
int main() {
//不能返回局部变量的引用
int& ref = test01();
cout << "ref = " << ref << endl;//第一次结果正确，是因为编译器做了保留
cout << "ref = " << ref << endl;//第二次结果错误，因为a的内存已经释放
//如果函数做左值，那么必须返回引用
int& ref2 = test02();
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
test02() = 1000;
cout << "ref2 = " << ref2 << endl;
cout << "ref2 = " << ref2 << endl;
system("pause");
return 0;
}
5 引用的本质在C++内部实现是一个指针常量
const修饰指针有三种情况：
const修饰指针 常量指针
const int * p1 = &a；指针的指向可以修改，但是指针指向的值不可以改。如：* p = 20；是错误的，p = &b；是正确的。
const修饰常量 指针常量
int * const p= &a; 指针的指向不可以改，指针指向的值可以改。如：* p = 20；是正确的，p = &b；是错误的。
const既修饰指针，又修饰常量
const int * const p = &a; 指针的指向和指针指向的值都不可以改。如：* p = 20；是错误的，p = &b；是错误的。
//发现是引用，转换为 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;
}
6 C++推荐用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了
7 常量引用主要用来修饰形参，防止误操作
//引用使用的场景，通常用来修饰形参
void showValue(const int& v) {
//v += 10;
cout << v << endl;
}
int main() {
//int& ref = 10; 引用本身需要一个合法的内存空间，因此这行错误
//加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
const int& ref = 10;
//ref = 100; //加入const后不可以修改变量
cout << ref << endl;
//函数中利用常量引用防止误操作修改实参
int a = 10;
showValue(a);
system("pause");
return 0;
}
三、函数提高
1 函数形参列表中的形参是可以有默认值的
语法：返回值类型 函数名（参数=默认值）{}
调用函数时若给了实参就用给的实参参与运算，如果没给就用默认的作为实参。
2 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
3 函数声明和函数实现只能有一个有默认参数
4 C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置
//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
cout << "this is func" << endl;
}
int main() {
func(10,10); //占位参数必须填补
system("pause");
return 0;
}
5 占位参数还可以有默认参数
6 函数重载：即函数名可以相同
需满足的条件：
在同一个作用域下
函数名称相同
函数参数类型不同或者个数不同或者顺序不同
7 函数返回值不可以作为函数重载的条件
如：
void func（）
int func（）是不可以的
8 引用作为重载条件时
函数重载碰到函数默认参数
//函数重载注意事项
//1、引用作为重载条件
void func(int &a)
{
cout << "func (int &a) 调用 " << endl;
}
void func(const int &a)
{
cout << "func (const int &a) 调用 " << endl;
}
//2、函数重载碰到函数默认参数
void func2(int a, int b = 10)
{
cout << "func2(int a, int b = 10) 调用" << endl;
}
void func2(int a)
{
cout << "func2(int a) 调用" << endl;
}
int main() {
int a = 10;
func(a); //调用无const
func(10);//调用有const
//func2(10); //碰到默认参数产生歧义，需要避免
system("pause");
return 0;
}
四、类和对象
1 C++面向对象的三大特性：封装、继承、多态。
2 封装
语法：
class 类名{ 访问权限：属性 / 行为 }；
例如：
//圆周率
const double PI = 3.14;
//1、封装的意义
//将属性和行为作为一个整体，用来表现生活中的事物
//封装一个圆类，求圆的周长
//class代表设计一个类，后面跟着的是类名
class Circle
{
public: //访问权限 公共的权限
//属性
int m_r;//半径
//行为
//获取到圆的周长
double calculateZC()
{
//2 * pi * r
//获取圆的周长
return 2 * PI * m_r;
}
};
int main() {
//通过圆类，创建圆的对象
// c1就是一个具体的圆
Circle c1;
c1.m_r = 10; //给圆对象的半径 进行赋值操作
//2 * pi * 10 = = 62.8
cout << "圆的周长为： " << c1.calculateZC() << endl;
system("pause");
return 0;
}
3 设计一个学生类，属性有姓名和学号，可以给姓名和学号赋值，可以显示学生的姓名和学号
//学生类
class Student {
public:
void setName(string name) {
m_name = name;
}
void setID(int id) {
m_id = id;
}
void showStudent() {
cout << "name:" << m_name << " ID:" << m_id << endl;
}
public:
string m_name;
int m_id;
};
int main() {
Student stu;
stu.setName("德玛西亚");
stu.setID(250);
stu.showStudent();
system("pause");
return 0;
}
4 类中的属性和行为，我们统一称为“成员”
属性又叫“成员属性”，“成员变量”
行为又叫“成员函数”，“成员方法”
5 访问权限
public 公共权限 成员类内可以访问，类外可以访问
protected 保护权限 成员类内可以访问，类外不可以访问（如main函数中） 在继承中儿子也可以访问父亲中的保护内容
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 p;
p.m_Name = "李四";
//p.m_Car = "奔驰"; //保护权限类外访问不到
//p.m_Password = 123; //私有权限类外访问不到
system("pause");
return 0;
}
6 struct和class的唯一区别是默认的访问权限不同
struct默认权限为公共
class默认权限为私有
7 将成员属性设置为私有有两点好处：
可以自己控制读写权限
对于写可以检测数据的有效性
class Person {
public:
//姓名设置可读可写
void setName(string name) {
m_Name = name;
}
string getName()
{
return m_Name;
}
//获取年龄
int getAge() {
return m_Age;
}
//设置年龄
void setAge(int age) {
if (age < 0 || age > 150) {
cout << "你个老妖精!" << endl;
return;
}
m_Age = age;
}
//情人设置为只写
void setLover(string lover) {
m_Lover = lover;
}
private:
string m_Name; //可读可写 姓名
int m_Age; //只读 年龄
string m_Lover; //只写 情人
};
int main() {
Person p;
//姓名设置
p.setName("张三");
cout << "姓名： " << p.getName() << endl;
//年龄设置
p.setAge(50);
cout << "年龄： " << p.getAge() << endl;
//情人设置
p.setLover("苍井");
//cout << "情人： " << p.m_Lover << endl; //只写属性，不可以读取
system("pause");
return 0;
}
五、文件操作
总结
