对于这种很宽泛的发问形式，一定要展现自己知识面的体系，以及在陈述问题的逻辑性，比如：

1.一定要先谈谈多态的分类，不然面对这么大的话题很容易讲成一锅粥，下面的分类都可以稍作展开讲讲

• 重载多态（Ad-hoc Polymorphism，编译期）：函数重载、运算符重载
• 子类型多态（Subtype Polymorphism，运行期）：虚函数
• 参数多态性（Parametric Polymorphism，编译期）：类模板、函数模板
• 强制多态（Coercion Polymorphism，编译期/运行期）：基本类型转换、自定义类型转换

2. 多态的重点其实在子类型多态

那么都知道是派生类调用虚函数的时候会体现多态，但是具体的对象调用具体的虚函数显然不是多态，多态有两个先决条件 （1）虚函数 ；(2) 一个基类的指针或引用指向派生类的对象；

3. 谈谈多态的用途等等

1 多态实现了一种所谓的晚绑定，在设计时可以先设计稳定不变的部分，设计中的不确定因素延迟到运行时确定。

2 设计模式里面几乎都是多态 比如策略模式 method模式等等

返回值，函数名称，形参列表

形参列表，包括个数，顺序，类型

切记返回值不能参与重载判定，函数只有调用后，编译器才会去验证返回类型，所以返回值不能作为函数重载的依据

算

成员函数后面的const 保证不修改成员变量的值

参考现代C++对象模型

class A{
public:
    virtual void func1(){
        std::cout<<"func1"<<std::endl;
    }
    void func2(){
        std::cout<<"func2"<<std::endl;
    }
private:
    int a;
};

int main(){
    A a;
    A b;
    std::cout<<sizeof(A)<<std:endl;
    std::cout<<&a<<" "<<&b<<std::endl;
}

16
0x7ffe9af23e00 0x7ffe9af23e10

继承是全盘继承，所有的数据成员，函数都继承了 ，只是对于不同的继承类型 ，会涉及到函数的调用权的差别

待补充（虚表的问题）

查表 调用派生类的虚函数

编译器为每一个类维护一个虚函数表，每个对象的首地址保存着该虚函数表的指针，同一个类的不同对象实际上指向同一张虚函数表

模板的出现将C++带上了一个全新的境界 ---元编程
在这个层面上编程可以忽略类型之间的差异，从而专注算法的本身实现

可以说没有模(mú)板技术就没有STL这么强大的组件

//比如有这样的一个模板函数
template<typename T1,typename T2 >
void fun(T1 t1,T2 t2) {
    //do_something
}
//全特化
void fun(int a,double b) {

}
//偏特化（类型范围上的偏）第一模板参数接受指针类型
template<typename T1, typename T2 >
void fun(T1* tp1,T2 t2 ) {

}
//偏特化（类型个数上的偏）固定部分模板参数
template<typename T1, typename T2 >
void fun(T1 a, double b) {

}

这个话题挺吊的 具体可以参考侯捷大佬的讲解

//举例来说 当通过push_back向vector中添加一个元素时 假设此时capacity是50 size也是50 我要放第51元素进去
_CONSTEXPR20_CONTAINER void push_back(const _Ty& _Val) { // insert element at end, provide strong guarantee
    //调用 emplace_back
    emplace_back(_Val);  
 }
|
---> //继续调用
template <class... _Valty>
    _CONSTEXPR20_CONTAINER decltype(auto) emplace_back(_Valty&&... _Val) {
        // insert by perfectly forwarding into element at end, provide strong guarantee
        auto& _My_data   = _Mypair._Myval2;
        pointer& _Mylast = _My_data._Mylast;
        //没到当前的最大容量 插入成功
        if (_Mylast != _My_data._Myend) {
            return _Emplace_back_with_unused_capacity(_STD forward<_Valty>(_Val)...);
        }
        // 到达极限容量 重新分配
        _Ty& _Result = *_Emplace_reallocate(_Mylast, _STD forward<_Valty>(_Val)...);
    ...
}
//*****************在这里会发生很重要的扩容*****************************
//**********************************************************************

template <class... _Valty>
_CONSTEXPR20_CONTAINER pointer _Emplace_reallocate(const pointer _Whereptr, _Valty&&... _Val) 
{
    //新的size等于老的size+1 插入一个元素  size==51
    const size_type _Newsize     = _Oldsize + 1;
    // 新的容量等于以原来的大小生长一倍 从而完成所谓的两倍扩容  capacity==100
    const size_type _Newcapacity = _Calculate_growth(_Newsize);
}

---- 答 用链表去串，追完：如何保留随机访问的性质？  我母鸡啊  这个到底要怎么做？？？

真的不知道 想了好几天了 哈哈

迭代器失效分三种情况考虑，也是分三种数据结构考虑，分别为数组型，链表型，树型数据结构。

数组型数据结构：该数据结构的元素是分配在连续的内存中，insert和erase操作，都会使得删除点和插入点之后的元素挪位置，所以，插入点和删除掉之后的迭代器全部失效，也就是说insert(*iter)(或erase(*iter))，然后在iter++，是没有意义的。解决方法：erase(*iter)的返回值是下一个有效迭代器的值。 iter =cont.erase(iter);

链表型数据结构：对于list型的数据结构，使用了不连续分配的内存，删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器.解决办法两种，erase(*iter)会返回下一个有效迭代器的值，或者erase(iter++).

树形数据结构： 使用红黑树来存储数据，插入不会使得任何迭代器失效；删除运算使指向删除位置的迭代器失效，但是不会失效其他迭代器。erase迭代器只是被删元素的迭代器失效，但是返回值为void，所以要采用erase(iter++)的方式删除迭代器。

//伪码
int main(){
    string s;
    while(cin>>s){
        for(char c:s){
            //存入字典树
        }
    }
    
    //查询
    //一个多叉树寻路的问题
    
}