345-C++复习(2)

r囧r小猫 2022-08-31 07:19 144阅读 0赞

## 关于static ##

**static函数**  
这个函数产生local符号，仅本文件可用。

**面向对象中的static**  
**1、static方法**  
没有像普通成员方法一样传递this指针（没有传递this指针）  
static成员方法中不可以使用非静态的成员！  
不依赖对象，可以直接使用类的作用域进行访问！

**2、static成员变量**  
一个类中只有一份！  
必须在类外进行初始化！  
访问不依赖于对象，可以直接使用类的作用域进行访问！

普通方法可以调动静态成员变量，静态方法。

## 初始化列表 ##

**什么东西要放在初始化列表？  
初始化列表的作用？**

**定义 — 构造** 其实**是一回事** 就是产生新量，对象也是变量  
int a; int a = 10; string s;  
**变量 — 对象 也是一回事**  
自定义类型产生的变量称为对象。内置类型我们直接叫变量。

int a;//只要定义了，就有内存，就有值，只是我们不知道是什么值。

**初始化**：定义的时候手动给了值  
**赋值**：定义完成之后给值

**初始化列表只有构造函数有**

class AA : public A
    {
        
    	string s;//成员对象
    	int a;
    	const int b;
    	int& c;
    	
    	AA()
    	:s("aaa")
    	{
        
    		_s = "ssss";//赋值，一定在定义之后
    	}
    };
    
    AA：：（AA有什么东西） 
    AA有：
    A::
    s
    a
    b
    c
    
    AA aaa;

**对象产生**：1.获得内存（空间） 2.定义成员（成员占位） 3.调用构造函数

**构造函数**开始调用之前一定要完成成员的定义  
**初始化列表**在构造函数调用**之前**运行，用来定义和初始化成员  
如果成员变量存在不需要参数的定义方式，系统可以自动为我们加到初始化列表  
如果成员不存在不需要参数的定义方式，我们就必须手动将它加到初始化列表  
**比如：**  
const & 没有默认构造函数的成员对象 没有默认构造函数的父类

## 继承 ##

**类与类之间的关系**  
**组合**：一个类是另一个类的一部分 eg：head – eye  
**代理**：一个类的某些功能完全依赖另一个类的功能 eg：deque，stack queue 的底层使用deque  
**继承**：一个类是另一个类的一种 eg：fish – goldfish  
**嵌套**：一个类中实现了另一个类

嵌套：
    class AA
    {
        
    	class B{
        };
    };
    AA::B b;

**父类–》子类权限：**  
public: 子类可以访问，外界可以访问  
protected: 子类可以访问，外界不可以访问  
private: 子类不可以访问，外界不可以访问

**继承权限：**  
public:  
protected:  
private:  
**父类中继承下来的成员的权限不能大于继承权限**

**默认继承权限**：private

## 函数之间的关系 ##

**重载** ： 函数名相同，参数列表不同，作用域相同 — 参数中的const如果不修饰指针或者引用，就不参与类型  
**不修饰指针指的是**:不修饰指针指向的内容

void fun(int a);
    void fun(const int a);  不构成重载
    
    void fun(int *a);
    void fun(int *const a);  不构成重载
    
    fun(new int());

**隐藏:**（就近原则）  
在继承中  
子类种的成员方法会隐藏父类中的同名的成员方法  
如果需要访问父类中同名的成员方法，需要加上父类的作用域

**覆盖：**  
在继承中  
子类的方法会覆盖父类中同样的**虚方法**  
同样：同返回值，同名，同参

**覆盖的原理：**  
虚函数表中存储虚函数指针  
子类中如果有满足覆盖条件的方法，就会在虚函数表中替换原有的父类的虚函数指针  
**当使用多态调用的时候**，会去虚函数表中寻找该函数指针，如果发生了覆盖，就调用覆盖之后的，造成父类中被覆盖的方法不可调用

## 多态 ##

**静多态：**  
函数的重载，编译时期的多态 ---- **早绑定**  
重载 模板

**动多态：**  
运行时期的多态 ------ **晚绑定**  
继承中的多态

**动多态：**（运行时的动态）  
使用指针或者引用调用虚函数  
对象必须完整

**对象完整：**  
构造函数调用完成  
析构函数还没开始

**eg:构造函数和析构函数中使用this调用虚函数无法产生动多态  
在存在虚函数的类实例化的对象中都会加入 vfptr**  
vfptr存储是**vftable的地址**  
vftable中存储着**虚函数的指针**  
当使用指针或者引用调用虚函数的时候，就会通过对象中的vfptr找到vftable，然后在vftable中找到该函数的位置，调用位置上的虚函数指针

**vftable：**  
存在虚函数的类都会有vftable，一个类只有一份  
存储在.rodata,**产生于编译期，一旦产生无法改变**  
vftable\[0\]位置存储的是RTTI–运行时期的状态  
其他位置存储**虚函数指针**  
vfptr指向的是vftable\[1\]位置

**RTTI ：**  
typeinfo 结构体指针  
typeinfo存储着当前对象运行起来的真实类型  
typeinfo结构产生于编译期  
存放在.rodatad段

//Base 必须有虚函数  
Base\* p = new Derive();  
cout<<typeid§.name()<<endl;//打印Base\*  
cout<<typeid(\*p).name()<<endl;//打印Derive

**基类指针指向子类对象：**  
基类指针指向子类对象指向的位置是子类对象中基类内存开始的位置  
如果基类指针指向堆上的子类对象，而且基类中没有虚函数，子类有虚函数，当delete基类指针时候，就崩溃了。

父类：Derive::
    
    子类：
    vfptr
    Base::
    基类指针指向的是Base，delete释放的时候从base释放，就崩溃了。。。

## 析构函数写成虚函数 ##

delete的过程：delete堆上的对象指针 --》调用析构 --》 释放内存  
**Derive继承Base**  
Base\* p = new Derive();  
**p指向的是对象中Base作用域开始的位置**，如果直接调用析构，调用的就只有Base的析构，Derive的析构不会调用。如果Base作用域开始位置不在对象的开始位置并且Base作用域中没有RTTI，还会崩溃

**造成上述情况的原因：**  
1.Base中析构函数没有写成虚函数，无法被子类中的析构函数覆盖

**什么情况下析构函数必须写成虚函数?**  
存在使用父类指针指向堆上的子类对象，那么父类的析构函数就必须写成虚函数，否则在这种情况下，delete父类指针时候，子类无法析构  
**这俩函数名相同，都叫析构**  
~Base  
~Derive

**构造能否写成虚函数?**  
**不能**  
1.构造函数不能手动调用  
2.构造函数用来产生对象，对象产生之后才有vfptr,才能找到vftable，才能找到虚函数指针。但是没有调用构造就没有这些，所有构造函数写成虚函数放在虚函数表中是矛盾的，没有意义的

**内联函数能否写成虚函数?**  
不能，虚函数必须要有函数指针，但是内联函数在release版本没有函数指针

**static方法能否写成虚函数?**  
不能，static函数调用不依赖对象，虚函数动多态调用需要依赖对象中的vfptr

## 智能指针 ##

**RAII** ： 使用对象管理申请的资源  
申请资源  
使用资源  
释放资源 **///程序员经常忘**  
**将动态内存地址放在对象中，利用对象的自动析构功能，完成指针的自动delete**

auto\_ptr 智能指针 **废弃了**

**unique\_ptr（唯一型智能指针）**  
不允许普通= 拷贝构造  
允许右值引用作为参数的 = 和拷贝构造 ----- 即将死亡的对象可以被 = 拷贝构造  
eg:函数返回局部/临时智能指针对象  
\*  
\->  
\[\]  
注意：**不能将一个资源给到多个智能指针**

int &&a = 10;  
const int& a = 10;  
**右值引用：**  
用来引用即将死亡的对象

**shared\_ptr（共享型智能指针）：**  
存在引用计数  
使用基本和普通指针一致  
线程安全：只是针对于**引用计数的变化**

## 交叉引用 ##

class A
    {
        
    	shared_ptr<B> _ptrb;
    }
    
    class B
    {
        
    	shared_ptr<A> _ptra;
    }
    
    shared_ptr<A>pa = new A();
    shared_ptr<B>pb = new B();
    
    pa->_ptrb = pb;
    pb->_ptra = pa;

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]  
**析构的时候就出现问题了！！！pb调用析构，把自己析构了，引用计数变为1，所以析构不了里面的\_ptra成员。pa调用析构，把自己析构了，引用计数变为1，所以析构不了里面的\_ptrb。交叉引用着。**

**解决：使用weak\_ptr**

如果构造函数中申请了资源之后，抛出异常，对象构造失败，不会调用析构，那么资源如何清除？  
**使用智能指针保存资源**

**weak\_ptr智能指针**  
会存储资源的地址，但是不会对资源进行惭怍  
**无法直接使用，不占用引用计数**  
如果要使用就**先转换为shared\_ptr 使用lock()函数**  
**如果转换的时候weak\_ptr中存储的指针对应的资源已释放，就会转换失败**

## stl ##

**1．顺序容器：**  
vector：向量容器。底层是动态开辟的一维数组  
deque：双端队列容器。底层是动态开辟的二维数组  
list：列表容器。底层是带头结点的双向链表容器

**2.关联容器：**  
set：单重集合，不允许数据重复。底层实现是红黑树  
multiset：多重集合，允许数据重复。底层实现是红黑树  
map：单重映射表，不允许数据重复。底层实现是红黑树  
multimap：多重映射表，允许数据重复。底层实现是红黑树

**3.容器适配器：**  
stack：栈。底层默认依赖deque容器来实现一个先进后出，后进先出的栈结构  
queue：队列。底层默认依赖deque实现一个先进先出，后进后出的队列结构  
priority\_queue：优先级队列。底层默认依赖vector实现一个大根堆结构，默认值越大，优先级越高

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70]: /images/20220829/07b142cb06f646aa943beb2aec8af896.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xJTlpFWVU2NjY_size_16_color_FFFFFF_t_70 1]: /images/20220829/a69c374ad77f4dafb17bd84da05eec68.png