注：以下内容是在B站学习黑马C++课程时的笔记。
C++核心编程
1. 内存分区模型
- C++程序执行时将内存划分为4个区域：
代码区 全局区 栈区 堆区 - 内存四区意义：
不同区域存放的数据，赋予不同的生命周期，提高编程灵活性
1.1 程序运行前
- 程序编译后，生成exe可执行程序，未执行该程序前分为两个区域
- 代码区：
存放函数体的二进制代码，供CPU执行，由操作系统管理；
代码区是共享的，频繁被执行的程序，内存中只有一份代码即可；
代码区是只读的，防止程序意外地修改它的指令； - 全局区：
存放全局变量和静态变量；
存放常量区，包括字符串常量和全局常量（const修饰的全局变量）；
该区域数据程序结束后由操作系统释放；//全局变量 int g_a = 10; //全局常量（const修饰的全局变量） const c_g_a = 10; int main() { //局部变量 int l_a = 10; //静态变量,普通变量前加static static int s_a = 10; //字符串常量 "Hello world"; //局部常量（const修饰的局部变量） const int c_l_a = 10; } //全局变量、全局常量、静态变量、字符串常量都在全局区！！ //局部变量、局部常量在栈区！！
1.2 程序运行后
- 栈区：
由编译器自动分配释放，存放函数的参数值、局部变量等；
注意：不要返回局部变量的地址，栈区数据函数执行完后会自动释放；//测试 返回局部变量地址 int *func() { int a = 10; //局部变量 return &a; //返回局部变量地址 } int main() { int *p = func(); cout << *p << endl; //第一次打印正确的数字10，因为编译器做了保留； cout << *p << endl; //第二次这个数据就不再保留了！ return 0; } - 堆区：
由程序员分配释放， 若程序员不释放，程序结束时由操作系统回收；
C++中主要利用new在堆区开辟内存；int *func() { //利用new关键字可以将数据开辟到堆区 int *p = new int(10); //会返回new出来的内存的地址，所以用指针*p接收 //这里p本质上还是在栈区开辟的数据，用于保存栈区中10的地址 return p; } int main() { int *p = func(); //虽然p在栈区被释放，但地址已经传递给了main函数中的指针 cout << *p << endl; //第一次打印正确的数字10 cout << *p << endl; //多次打印依然是10，因为指针p指向的内容在堆区不会被释放 //只要main函数不结束，main函数中的指针就会一直存在，一直指向10的地址 return 0; }
1.3new操作符
- C++利用
new操作符在堆区开辟数据； - 由程序员手动开辟，手动释放，释放利用操作符
delete； - 利用
new创建的数据，会返回该数据对应类型的指针；int *func() { int *p = new int(10); return p; } int main() { int *p = func(); cout << *p << endl; cout << *p << endl; delete p; cout << *p << endl; //异常，无法运行！ return 0; } - 在堆区利用
new开辟数组，使用delete []进行释放void *func() { int *arr = new int[10]; //10代表数组有10个元素 for (int i = 0; i < 10; i++) { arr[i] = i + 100; } //释放堆区数组时要加[]才可以 delete[] arr; }
2. 引用
2.1 基本使用
- 作用：给变量起别名；
- 格式：
数据类型 &别名 = 原名 - 引用必须初始化；
- 初始化后，不可以更改为其他变量的别名；
- 引用的本质在C++内部实现是一个指针常量！
int &ref = a;会被自动转换成int *const ref = &a;
ref = 100;解引用时也会自动转换为*ref = 100;
2.2 引用做函数参数
- 作用：函数传参时，可以利用引用让形参修饰实参；
- 优点：简化指针修改实参；
//值传递 void swap1(int a, int b) { int temp = a; a = b; b = temp; } // 地址传递 void swap2(int *p1, int *p2) { int temp = *p1; *p1 = *p2; *p2 = temp; } //引用传递 void swap3(int &a, int &b) { int temp = a; a = b; b = temp; } int main() { int a = 10; int b = 20; swap1(a, b); //值传递，形参不会修饰实参 cout << a << ' ' << b << endl; // 10 20 swap2(&a, &b); //地址传递，形参会修饰实参 cout << a << ' ' << b << endl; // 20 10 swap2(a, b); //引用传递，形参会修饰实参 cout << a << ' ' << b << endl; // 20 10 return 0; }
2.3 引用做函数返回值
- 注意：不要返回局部变量的引用；
- 用法：函数调用可以作为左值；
int &test01() { int a = 10; return a; } int &test02() { static int a = 10; //静态变量 return a; } int main() { //返回局部变量的引用 int &ref1 = test01(); cout << ref1 << endl; //10 cout << ref1 << endl; //异常！ int &ref2 = test02(); cout << ref2 << endl; //10 cout << ref2 << endl; //10 //函数调用作为左值 test02() = 1000; cout << ref2 << endl; //1000（ref是别名，会和原名a） cout << ref2 << endl; //1000 }
2.4 常量引用
- 作用：用来修饰形参，防止误操作（防止形参改变实参）；
- 不可以直接
int &ref = 10;，因为引用的必须是一块合法的内存空间； - 而
const int &ref =10;加上const后，编译器自动修改为int temp = 10; const int &ref = temp;void showValue(const int &val) { val = 1000; //这里就会报错！不允许修改！ cout << val << endl; } int main() { int a = 10; showValue(a); return 0; }
3. 函数提高
3.1 函数默认参数
- C++中，函数的形参可以有默认值；
- 如果某个位置有了默认参数值，那么从这个位置往右都必须有；
- 声明和实现只能有一个由默认参数，即：
1）如果函数声明有默认参数，函数实现就不能有默认参数；
2）如果函数实现有默认参数，函数声明就不能有默认参数；
3.2 函数占位参数
- C++中函数的形参可以有占位参数，调用函数时必须填补该位置；
- 语法：
返回值类型 函数名 (数据类型){} - 目前阶段，占位参数用不到，因为没法使用，后续会用到；
- 占位参数还可以有默认参数；
void func(int a, int){} //第二个int时占位参数 void func(int a, int = 10){} //占位参数的默认参数
3.3 函数重载
- 作用：函数名可以相同，提高复用性；
- 函数重载满足条件：
1）同一个作用域下；
2）函数名相同；
3）函数参数类型不同或者个数不同或者顺序不同； - 注意：函数返回类型不可以作为函数重载的条件；
void func() { cout << "func 的调用" << endl; } void func(int a) { cout << "func(int a)的调用!" << endl; } //int func(int a) //函数返回类型不可作为函数重载的条件 //{ // cout << "int func(int a) 的调用!" << endl; //} int main() { func(); //调用第一个 func(10); //调用第二个 return 0; } - 注意事项：
1）引用作为重载条件（属于参数类型不同）
2）函数重载碰到函数默认参数（尽量避免）void func(int &a) { cout << "func(int &a)" << endl;} void func(const int &a) { cout << "func(const int &a)" << endl;} int main() { int a = 10; func(a); //"func(int &a)"，因为int &a = 10 不合法 func(10); //"func(const int &a)"，const int &a = 10 合法 }void func(int a, int b = 10) { cout << "func(int a, int b = 10)" << endl;} void func(int a) { cout << "func(int a)" << endl;} int main() { func(10); //异常！！出现二义性！！ }
4. 类和对象（最重要内容！）
C++面向对象三大特性：封装、继承、多态；
4.1 封装
4.1.1 封装的意义
- 封装的意义：
1）将属性和行为作为一个整体
2）将属性和行为加以权限控制 - 封装意义一：
在设计类的时候，将属性和行为作为一个整体，表现事物
语法：class 类名{ 访问权限: 属性 / 行为 };
类中的属性和成员统一称为成员；
示例1：设计一个圆类，求周长const double PI = 3.14; class Circle { //访问权限：公共权限 public: //属性（成员属性/成员变量）：半径 int m_r; //行为（成员函数/成员方法）：计算周长 double calculateZC() { return 2 * PI * m_r; } }; int main() { //通过圆类，创建具体的圆（对象） //这个过程叫实例化（通过一个类，创建一个对象的过程） Circle c1; c1.m_r = 10; cout << "圆的周长为：" << c1.calculateZC() << endl; } - 封装意义二：
在设计类的时候，可以把属性和行为放在不同的权限下，加以控制
访问权限有三种：
保护权限和私有权限的区别在于继承：名称 含义 权限 public公共权限 类内可以访问 类外可以访问 protected保护权限 类内可以访问 类外不可以访问 private私有权限 类内可以访问 类外不可以访问
子类可以访问父类中的保护内容
子类不可访问父类中的私有内容
4.1.2 struct和class的区别
- 唯一的区别在于默认的访问权限不同：
struct默认权限为公共；class默认权限为私有；
class C1 { int m_A; //默认为私有权限 }; struct S1 { int m_A; //默认为公共权限 };
4.1.3 成员属性设置为私有
- 优点1：将所有成员属性设置为私有，可以自己控制读写权限；
- 优点2：对于写权限，可以检测数据的有效性；
class Student { public: void setName(string name) { m_Name = name; } string getName() { return m_Name; } int getAge() { m_Age = 0; return m_Age; } void setLover(string lover) { m_Lover = lover; } private: string m_Name; //设置为可读可写 int m_Age; //设置为只读 string m_Lover; //设置为只写 };//对于写权限，可以检测数据有效性 //假如把年龄设置为可读可写，如果想修改，年龄范围必须是0~150 int getAge() { return m_Age; } void setAge(int age) { if (age < 0 || age > 150) { m_Age = -1; cout << "输入有误！" << endl; return; } m_Age = age; }
4.2 对象的初始化和清理
4.2.1 构造函数和析构函数
- 构造函数和析构函数是编译器自动调用，用于完成对象的初始化和清理工作，这个工作时编译器强制要求做的事情；如果不提供构造和析构，编译器会提供，但是提供的构造函数和析构函数是空实现；
- 构造函数：主要作用是创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
- 析构函数：主要作用是对象销毁前系统自动调用，执行一些清理工作。
- 构造函数语法：
类名(){}
1）无返回值也不写void；
2）函数名称与类名相同；
3）可以有参数，因此可以发生重载；
4）程序在调用对象时会自动调用构造，且只会调用一次，无需手动； - 析构函数语法：
~类名(){}
1）无返回值也不写void；
2）名称前加~；
3）不可以由参数，因此不可发生重载；
4）程序在对象销毁前会自动调用析构，且只会调用一次，无需手动；class Person { public: //构造函数 Person() { cout << "Person构造函数的调用" << endl; } //析构函数 ~Person() { cout << "Person析构函数的调用" << endl; } }; void test01() { Person p; //栈区的数据，test01执行完毕后会释放对象 } int main() { test01(); } //结果： // Person构造函数的调用 // Person析构函数的调用
4.2.2 构造函数的分类及调用
- 分类方式：
按参数分为：有参构造和无参构造（默认构造）
按类型分为：普通构造和拷贝构造class Person { public: int age; //无参构 Person() { cout << "Person无参构造函数的调用" << endl; } //有参构造 Person(int a) { age = a; cout << "Person有参构造函数的调用" << endl; } //拷贝构造 Person(const Person &p) { age = p.age; cout << "Person拷贝构造函数的调用" << endl; } //析构函数 ~Person() { cout << "Person析构函数的调用" << endl; } }; - 调用方式：
括号法；显示法；隐式转换法；void test() { //1.括号法 Person p1; //默认构造的调用 Person p2(10); //有参构造的调用 Person p3(p2); //拷贝构造的调用 //注意事项一：调用默认构造时不要加`()`！编译器会认为是一个函数声明。 //2.显示法(等号右侧称为匿名对象，当前行执行结束后系统立刻回收) Person p1; Person p2 = Person(10); //有参构造的调用 Person p3 = Person(p2); //拷贝构造的调用 //注意事项二：不要利用拷贝构造函数来初始化匿名对象！编译器会认为是一个对象声明。 //Person(p3); 编译器会认为等价于Person p3，即对象声明，和上面的p3造成重定义; //3.隐式转换法 Person p4 = 10; //相当于 Person p4 = Person(10); Person p5 = p4; //拷贝构造的调用； }
2区8 1
5区1号楼 大门近一些
4.2.3 拷贝构造函数调用时机
拷贝构造函数的调用时机有三种情况：
- 使用一个已经创建完毕的对象初始化一个新对象；
void test01() { Person p1(20); Person p2(p1); } - 值传递的方式给函数参数传值；
void doWork(Person p) //值传递 { } void test02() { Person p; doWork(p); //会调用拷贝构造函数 } - 以值方式返回局部对象；
Person doWork2() { Person p1; return p1; } void test03() { Person p = doWork2(); //会调用拷贝构造函数 }
4.2.4 构造函数调用规则
- 默认情况下，C++编译器至少给一个类添加3个函数：
1）默认构造函数（无参，函数体为空）
2）默认析构函数（无参，函数体为空）
3）默认拷贝构造函数（对属性进行值拷贝） - 构造函数调用规则：
1）如果用户定义了有参构造函数，C++不再提供默认无参构造，但会提供默认拷贝构造
2）如果用户定义了拷贝构造函数，C++不再提供其他构造函数
4.2.5 深拷贝与浅拷贝（面试常见坑）
- 浅拷贝：简单地复制拷贝操作
- 深拷贝：在堆区重新申请空间，进行拷贝操作
- 大坑：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防治浅拷贝带来的问题
class Person { public: int m_Age; int *m_Height; Person() { cout << "Person默认构造函数的调用" << endl; } Person(int age, int height) { m_Age = age; m_Height = new int(height); cout << "Person有参构造函数的调用" << endl; } Person(const Person &p) { //如果不利用深拷贝在堆区创建新内容， //会导致浅拷贝带来的重复释放堆区问题！！ m_Age = p.m_Age; m_Height = new int(*p.m_Height); cout << "Person拷贝构造函数的调用" << endl; } ~Person() { //析构代码，将堆区开辟的数据做释放操作 if (m_Height != NULL) { delete m_Height; m_Height = NULL; //防止野指针的出现 } cout << "Person析构函数的调用" << endl; } }; void test01() { Person p1(20, 180); Person p2(p1); //如果不利用深拷贝在堆区创建新内容，则只进行了简单的浅拷贝， //p1.m_Height和p2.m_Height将存储同一块堆区内存的地址， //在p1和p2析构时，会导致统一内存重复释放！！ }
4.2.6 初始化列表
- 作用：初始化属性
- 语法：
构造函数(): 属性1(值1), 属性2(值2) ... { }class Person { public: int m_A; int m_B; int m_C; //传统初始化操作） Person(int a, int b, int c) { m_A = a; m_B = b; m_C = c; } //初始化列表方式初始化 Person(int a, int b, int c) : m_A(a), m_B(b), m_C(c) { } }; void test() { Person p(10, 20, 30); }
4.2.7 类对象作为类成员
- 类中的成员可以是另一个类的对象，称该成员为对象成员；
class A {} class B { A a; } - 当创建B对象时，A与B的构造和析构的顺序？
构造时，先调用对象成员的构造，再调用本类构造；
析构时，与构造顺序相反；class Phone { public: string m_PName; Phone(string pName) { m_PName = pName; cout << "Phone的构造函数" << endl; } ~Phone() { cout << "Phone的析构函数" << endl; } }; class Person { public: string m_Name; Phone m_Phone; Person(string name, string pName) : m_Name(name), m_Phone(pName) { cout << "Person的构造函数" << endl; } ~Person() { cout << "Person的析构函数" << endl; } }; void test() { Person p("张三", "华为"); cout << p.m_Name << " 拿着 " << p.m_Phone.m_PName << endl; } int main() { test(); return 0; }
4.2.8 静态成员
- 静态成员就是在成员变量和成员函数前加上关键字
static，称为静态成员 - 静态成员变量：
所有对象共享同一份数据；
在编译阶段分配内存；
类内声明，类外初始化；class Person { public: static int m_A; }; int Person::m_A = 100; void test() { Person p1; cout << p1.m_A << endl; //100 Person p2; p2.m_A = 200; cout << p1.m_A << endl; //200 } - 静态成员变量的两种访问方式：
1）通过对象进行访问，p.m_A
2）通过类名进行访问，Person::m_A
另外，静态成员变量也是有访问权限的！ - 静态成员函数：
所有对象共享同一个函数；
静态成员函数只能访问静态成员变量；
静态成员函数的两种访问方式同上，也是有访问权限的；
4.3 C++对象模型和this指针
4.3.1 成员变量和成员函数 分开存储
- C++中，类内的成员变量和成员函数分开存储；
- 只有非静态成员变量才属于类的对象上；
class P1 {}; //空对象占用内存1字节，每个空对象都有一个内存地址 class P2 { int m_A; }; //占用4字节（内存对齐） class P3 //占用4字节 { int m_A; static int m_B;}; class P3 //占用4字节 { int m_A; //非静态成员变量 属于类对象 static int m_B; //静态成员变量 不属于类对象 void func1() {} //非静态成员函数 不属于类对象 static void func2() {} //静态成员函数 不属于类对象 };
4.3.2 this指针
每一个非静态成员函数只会诞生一份函数实例，多个同类型对象共用一块代码，那么这一块代码如何区分是哪个对象调用的呢？
C++特殊的对象指针，this指针，指向被调用的成员函数所属的对象；
- this指针隐含在每一个非静态成员函数内；
- this指针不需要定义，直接使用即可；
- this指针的用途：
1）解决名称冲突，当形参和成员变量同名时，可用this指针来区分
2）在类的非静态成员函数中返回对象本身，可使用return *thisclass Person { public: int age; Person(int age) { this->age = age; } Person &PersonAddAge(Person &p) { this->age += p.age; return *this; } }; void test() { Person p1(10); Person p2(10); //链式编程思想 p2.PersonAddAge(p1).PersonAddAge(p1).PersonAddAge(p1); cout << p2.age << endl; //输出结果为40 } int main() { test(); return 0; }
4.3.3 空指针访问成员函数
- 空指针也可以调用成员函数，但是要注意有没有用到this指针；
- 如果用到this指针，需要加以判断保证代码的健壮性；
class Person { public: int m_Age; void showClassName() { cout << "This is Person class" << endl; } void showAge() { //提高健壮性 if (this == NULL) //如果没有这个,会报错 { return; } //m_Age 相当于 this->m_Age cout << "age = " << m_Age << endl; } }; void test() { Person *p = NULL; p->showClassName(); p->showAge(); } int main() { test(); return 0; }
4.3.4 const修饰成员函数
常函数：
- 成员函数后加
const后称为常函数； - 常函数内不可以修改成员属性；
- 成员属性声明时加关键字
mutable后，在常函数中依然可以修改；
class Person
{
public:
int m_A;
mutable int m_B; //特殊变量，即使在常函数中也可修改
//this指针本质时指针常量，指向不可修改；
//成员函数后加const，本质修饰的时this指针；
//所以就相当于const Person *const this;
void showPerson() const
{
this->m_A = 100; //会报错！
this->m_B = 100; //不会报错
}
void func()
{
m_A = 100;
}
};
常对象：
- 声明对象前加
const称为常对象； - 常对象只能调用常函数；
void test()
{
const Person p; //常对象
p.m_A = 100; //会报错！
p.m_B = 100; //不会报错
p.showPerson();
p.func(); //会报错！
//常对象不可调用普通成员函数，因为普通成员函数可以修改属性
}
432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
