[笔记]黑马C++核心编程

int main() {

    int a = 10;
    int b = 20;
    //int &c; //错误，引用必须初始化
    int &c = a; //一旦初始化后，就不可以更改
    c = b; //这是赋值操作，不是更改引用

    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;

    system("pause");

    return 0;
}

其中int &c=a; 有&才算引用不能再写什么int &c =b 把c的引用改了，但是可以把c的值改了。

2.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;
}

引用传递可以跟指针一样的效果即改变实参但是在函数里形参就像普通的变量一样只是形参列表里要加&表示引用引用进函数里面了就可以像普通变量一样进行运算表现。

2.4 引用做函数返回值

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

注意：不要返回局部变量引用

用法：函数调用作为左值

int& test01() {
    int a = 10; //局部变量
    return a;
}

 int& ref = test01();
    cout << "ref = " << ref << endl;
    cout << "ref = " << ref << endl;

第一个ref输出是10 正常的是编译器给我们保留的，但是第二个ref输出错误，因为本质上我们在这里把返回的局部变量(int&）用ref接收，去引用掉了 .

因为局部变量在栈区用完释放掉了不能再接收引用

但是我们可以这样：

//返回静态变量引用
int& test02() {
    static int a = 20;
    return a;
}

  int& ref2 = test02();
    cout << "ref2 = " << ref2 << endl;
    cout << "ref2 = " << ref2 << endl;

把局部变量a带上了静态存放在了全局区，在程序结束后才释放，test02结束后保留。

这样输出的ref2都是正常的20

左值：等号的左边

这个时候可以再加入

    test02() = 1000;

把函数返回值调用，作为左值进行赋值，这样接下去我们输出

   cout << "ref2 = " << ref2 << endl;
    cout << "ref2 = " << ref2 << endl;

得到的结果变成了1000

2.5 引用的本质

本质：引用的本质在c++内部实现是一个指针常量.

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

2.6 常量引用

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

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

引用加上const：const int &p=const int* const p

 //int& ref = 10;  引用本身需要一个合法的内存空间，因此这行错误
    //加入const就可以了，编译器优化代码，int temp = 10; const int& ref = temp;
    const int& ref = 10;

&ref这个引用不能直接等于一个数字10 数字10没有占用空间必须要等于一个变量因为变量定义的时候已经被分配空间给他了

3 函数提高

3.1 函数默认参数

在C++中，函数的形参列表中的形参是可以有默认值的。

语法： 返回值类型函数名（参数= 默认值）{}

如果传递的和默认的不一样以传递的为准函数定义里的默认的值忽略

注意：

//1. 如果某个位置参数有默认值，那么从这个位置往后，从左向右，必须都要有默认值
//2. 如果函数声明有默认值，函数实现的时候就不能有默认参数

声明≠定义声明就是直接说一句我要定义一个函数啦提前打个招呼

也就是说声明和实现里只能有一个地方有默认值，为了不产生歧义

函数实现＝定义 ≠调用调用在main函数里

3.2 函数占位参数

C++中函数的形参列表里可以有占位参数，用来做占位，调用函数时必须填补该位置

语法： 返回值类型函数名 (数据类型){}

//函数占位参数 ，占位参数也可以有默认参数
void func(int a, int) {
    cout << "this is func" << endl;
}

int main() {

    func(10,10); //占位参数必须填补

    system("pause");

    return 0;
}

但是形参列表里数据类型必须要写啊可以不命名

占位参数还可以有默认参数所以只要不命名其他都行

3.3 函数重载

3.3.1 函数重载概述

作用：函数名可以相同，提高复用性

函数重载满足条件：

同一个作用域下 (全在全局里)
函数名称相同
函数参数类型不同 或者 个数不同 或者 顺序不同

注意: 函数的返回值不可以作为函数重载的条件

就是不能俩函数一个int func1 一个double func1

这俩个编译器还是分不清要哪个的

也要注意默认参数的函数重载会不会产生歧义

4 类和对象

C++面向对象的三大特性为：==封装、继承、多态==

C++认为==万事万物都皆为对象==，对象上有其属性和行为

例如：

人可以作为对象，属性有姓名、年龄、身高、体重...，行为有走、跑、跳、吃饭、唱歌...

车也可以作为对象，属性有轮胎、方向盘、车灯...,行为有载人、放音乐、放空调...

具有相同性质的==对象==，我们可以抽象称为==类==，人属于人类，车属于车类

4.1 封装

4.1.1 封装的意义

封装是C++面向对象三大特性之一

封装的意义：

将属性和行为作为一个整体，表现生活中的事物
将属性和行为加以权限控制

封装意义一：

在设计类的时候，属性和行为写在一起，表现事物

语法： class 类名{ 访问权限：属性 / 行为 };

实例化：通过一个类，创造一个对象

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

访问权限有三种：

public 公共权限
protected 保护权限
private 私有权限

//三种权限
//公共权限  public     类内可以访问  类外可以访问
//保护权限  protected  类内可以访问  类外不可以访问
//私有权限  private    类内可以访问  类外不可以访问

这三者类内都可以随便访问

保护权限：父权限和子权限可以继承子可以访问父中保护内容

私有：子不能访问父的私有内容

4.1.2 struct和class区别

在C++中 struct和class唯一的区别就在于 默认的访问权限不同

区别：

struct 默认权限为公共
class 默认权限为私有（类外不能访问）是默认当然你可以声明成public

4.1.3 成员属性设置为私有

优点1：将所有成员属性设置为私有，可以自己控制读写权限

优点2：对于写权限，我们可以检测数据的有效性

4.2 对象的初始化和清理

4.2.1 构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。

对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会提供

编译器提供的构造函数和析构函数是空实现。

构造函数：主要作用在于创建对象时为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用。
析构函数：主要作用在于对象销毁前系统自动调用，执行一些清理工作。

构造函数语法：类名(){}

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象时候会自动调用构造，无须手动调用,而且只会调用一次

析构函数语法： ~类名(){}

析构函数，没有返回值也不写void
函数名称与类名相同,在名称前加上符号 ~
析构函数不可以有参数，因此不可以发生重载（）里面不可以有参数！！
程序在对象销毁前会自动调用析构，无须手动调用,而且只会调用一次

4.2.2 构造函数的分类及调用

两种分类方式：

按参数分为：有参构造和无参构造（）里有无参数int a这种

按类型分为：普通构造和拷贝构造拷贝构造：Person(const Person &p) //加入了const 和取址

三种调用方式：

括号法

    Person p1(10);

显示法

    Person p2 = Person(10); 
    Person p3 = Person(p2);

隐式转换法

    Person p4 = 10; // Person p4 = Person(10); 
    Person p5 = p4; // Person p5 = Person(p4);

注意1：调用无参构造函数不能加括号，如果加了编译器认为这是一个函数声明

比如Person p1;生成一个对象可以这样调用构造函数但是不能

Person p1(); 不然编译器以为是一个全新的函数的声明

//注意2：不能利用 拷贝构造函数 初始化匿名对象 编译器认为是对象声明

比如不能Person p3=Person（10）；//把P3变成匿名对象10

下面再跟一行Person （p3）.因为编译器会去掉括号以为是Person p3；以为是p3的重复定义

匿名对象：比如像Person（10);这样的。匿名对象的特点是当前行执行结束后，系统会自动回收掉匿名对象。

4.2.3 拷贝构造函数调用时机

C++中拷贝构造函数调用时机通常有三种情况

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象

4.2.4 构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1．默认构造函数(无参，函数体为空)

2．默认析构函数(无参，函数体为空)

3．默认拷贝构造函数，对属性进行值拷贝

构造函数调用规则如下：

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造给2不给1

如果用户定义拷贝构造函数，c++不会再提供其他构造函数给3不给12

4.2.5 深拷贝与浅拷贝

深浅拷贝是面试经典问题，也是常见的一个坑

浅拷贝：简单的赋值拷贝操作

深拷贝：在堆区重新申请空间，进行拷贝操作

注意：浅拷贝可能带来重复释放，报错。此时要自己定义一个拷贝构造函数然后里面用new开辟新空间

因为用new开辟的区域都在堆区

总结：如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题

4.2.6 初始化列表

作用：

C++提供了初始化列表语法，用来初始化属性

语法：构造函数()：属性1(值1),属性2（值2）... {}

注意构造函数后面有个冒号：

4.2.7 类对象作为类成员

C++类中的成员可以是另一个类的对象，我们称该成员为对象成员

例如：

class A {}
class B
{
    A a；
}

B类中有对象A作为成员，A为对象成员

构造的顺序是：先调用对象成员A的构造，再调用本类B构造，先里面后外面

析构的顺序刚好相反，先析构出外面的再析构里面的

4.2.8 静态成员

静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员

静态成员分为：

静态成员变量
- 所有对象共享同一份数据
- 在编译阶段分配内存
- 类内声明，类外初始化

访问方式：1、通过对象 2、通过类名

当然，私有的静态成员我们访问不了。

静态成员函数
- 所有对象共享同一个函数
- 静态成员函数只能访问静态成员变量，不能访问非静态的成员变量

因为静态成员变量是共享的一份，可以访问修改，但是如果不是静态的，你要访问，编译器无法区分你访问哪个成员的变量

4.3 C++对象模型和this指针

4.3.1 成员变量和成员函数分开存储

在C++中，类内的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

C++编译器会给每个空对象分配1个空间，sizeof=1。每个空对象的内存地址是独一无二的，不共享

静态成员变量和非静态的成员函数都不属于类的对象上，不会扩展类的占用空间

4.3.2 this指针概念（this->）

通过4.3.1我们知道在C++中成员变量和成员函数是分开存储的

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分那个对象调用自己的呢？

c++通过提供特殊的对象指针，this指针，解决上述问题。this指针指向被调用的成员函数所属的对象

this指针是隐含每一个非静态成员函数内的一种指针

this指针不需要定义，直接使用即可

this指针的本质是一个指针常量，指针的指向不可以修改

this指针的用途：

当形参和成员变量同名时，可用this指针来区分
在类的非静态成员函数中返回对象本身，可使用return *this

说白了 this指针是为了解决名称冲突，或者在返回对象本身的时候，用*this。

第二种可以用于链式操作

4.3.3 空指针访问成员函数

C++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断保证代码的健壮性

4.3.4 const修饰成员函数

常函数：

成员函数后加const后我们称为这个函数为常函数因为成员函数里隐藏了一个this指针
常函数内不可以修改成员属性
特别的★成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

声明对象前加const称该对象为常对象比如const Person p；表示对象的属性不可以修改，访问≠修改
常对象只能调用常函数，不能调用普通函数

注意：const void function（）指的是这个函数返回值是常量

void function（） const｛｝指的是这个函数里的this指针指向的值也不能变，本质上这个const修饰了函数里的this指针

4.4 友元

生活中你的家有客厅(Public)，有你的卧室(Private)

客厅所有来的客人都可以进去，但是你的卧室是私有的，也就是说只有你能进去

但是呢，你也可以允许你的好闺蜜好基友进去。

在程序里，有些私有属性也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的就是让一个函数或者类访问另一个类中私有成员

友元的关键字为 ==friend==

友元的三种实现

全局函数做友元
类做友元
成员函数做友元

注意：指针的属性用->，对象的属性用.

4.5 运算符重载

运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

总结1：对于内置的数据类型的表达式的的运算符是不可能改变的

4.5.2 左移运算符重载

作用：可以输出自定义数据类型

首先，我们不会用成员函数重载<<运算符，因为无法实现cout在左侧。

总结：重载左移运算符配合友元可以实现输出自定义数据类型

4.5.3 递增运算符重载

作用：通过重载递增运算符，实现自己的整型数据

总结：前置递增返回引用，后置递增返回值

4.5.4 赋值运算符重载

c++编译器至少给一个类添加4个函数

默认构造函数(无参，函数体为空)
默认析构函数(无参，函数体为空)
默认拷贝构造函数，对属性进行值拷贝
赋值运算符 operator=, 对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

4.5.6 函数调用运算符重载

函数调用运算符 () 也可以重载
由于重载后使用的方式非常像函数的调用，因此称为仿函数
仿函数没有固定写法，非常灵活

4.6 继承

继承是面向对象三大特性之一

总结：

继承的好处：==可以减少重复的代码==

比如 class A : public B;

A 类称为子类或派生类

B 类称为父类或基类

派生类中的成员，包含两大部分：

一类是从基类继承过来的，一类是自己增加的成员。

从基类继承过过来的表现其共性，而新增的成员体现了其个性。

4.6.2 继承方式

继承的语法：class 子类 : 继承方式父类

继承方式一共有三种：

公共继承
保护继承
私有继承

什么继承都无法访问私有成员

公共继承后保护和公共不变

保护继承后保护和公共都变保护

私有继承后保护和公共都变私有

4.6.3 继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象中？

结论：父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

4.6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数

问题：父类和子类的构造和析构顺序是谁先谁后？

总结：继承中先调用父类构造函数，再调用子类构造函数，析构顺序与构造相反

4.6.5 继承同名成员处理方式

问题：当子类与父类出现同名的成员，如何通过子类对象，访问到子类或父类中同名的数据呢？

访问子类同名成员直接访问即可
如果通过子类对象访问父类同名成员需要加作用域

总结：

子类对象可以直接访问到子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

总结：同名静态成员处理方式和非静态处理方式一样，只不过有两种访问的方式（通过对象和通过类名）

4.6.7 多继承语法

C++允许一个类继承多个类

语法： class 子类：继承方式父类1 ，继承方式父类2...

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

菱形继承问题：

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性。

草泥马继承自动物的数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

总结：

菱形继承带来的主要问题是子类继承两份相同的数据，导致资源浪费以及毫无意义
利用虚继承可以解决菱形继承问题继承之前加上virtual就是虚继承

4.7 多态

4.7.1 多态的基本概念

多态是C++面向对象三大特性之一

多态分为两类

静态多态: 函数重载和运算符重载属于静态多态，复用函数名
动态多态: 派生类和虚函数实现运行时多态

静态多态和动态多态区别：

静态多态的函数地址早绑定 - 编译阶段确定函数地址
动态多态的函数地址晚绑定 - 运行阶段确定函数地址

总结：

多态满足条件

有继承关系
子类重写父类中的虚函数（子类中的虚函数表内部会替换成子类的虚函数地址）

多态使用条件

父类指针或引用指向子类对象

重写：函数返回值类型函数名参数列表完全一致称为重写

4.7.3 纯虚函数和抽象类

在多态中，通常父类中虚函数的实现是毫无意义的，主要都是调用子类重写的内容

因此可以将虚函数改为纯虚函数

纯虚函数语法：virtual 返回值类型函数名（参数列表）= 0 ;

当类中有了纯虚函数，这个类也称为==抽象类==

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也属于抽象类

4.7.5 虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码，导致如果子类有堆区属性会有内存泄露

解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都需要有具体的函数实现

虚析构和纯虚析构区别：

如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：

virtual ~类名(){}

纯虚析构语法：

virtual ~类名() = 0;

类名::~类名(){}

总结：

1. 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象

2. 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构

3. 拥有纯虚析构函数的类也属于抽象类

5 文件操作

程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放

通过文件可以将数据持久化

C++中对文件操作需要包含头文件 ==< fstream >==

文件类型分为两种：

文本文件 - 文件以文本的ASCII码形式存储在计算机中
二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

操作文件的三大类:

ofstream：写操作
ifstream：读操作
fstream ：读写操作

5.1文本文件

5.1.1写文件

写文件步骤如下：

包含头文件

#include <fstream>
创建流对象

ofstream ofs;
打开文件

ofs.open("文件路径",打开方式);
写数据

ofs << "写入的数据";
关闭文件

ofs.close();

文件打开方式：

打开方式	解释
ios::in	为读文件而打开文件
ios::out	为写文件而打开文件
ios::ate	初始位置：文件尾
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式