What & How & Why

您在这里: start » cs » programming » cpp » courses » cpp_basic_deep » chpt_13

差别

这里会显示出您选择的修订版和当前版本之间的差别。

到此差别页面的链接

两侧同时换到之前的修订记录前一修订版
后一修订版		前一修订版
cs:programming:cpp:courses:cpp_basic_deep:chpt_13 [2024/11/18 03:59] – [纯虚函数] codingharecs:programming:cpp:courses:cpp_basic_deep:chpt_13 [2024/11/20 13:01] (当前版本) – [using 与重写] codinghare
行 323: 行 323:
   * 析构：先析构派生类成员   * 析构：先析构派生类成员
 ====补充知识==== ====补充知识====
 +===继承方式的影响===
 +影响的实际是被继承成员的访问权限：
 +  * ''public'' 继承：所有继承自父类的成员访问权限都不会发生改变
 +    * 实际上代表了 ''is-a'' 关系，因为继承了所有的行为
 +  * ''protect'' 继承：继承自父类中的，所有成员权限高于 ''protected'' 的，都会变为 ''protected''
 +    * 实际上代表了派生类的实现是基于基类的这样一种关系
 +  * ''private'' 继承：继承自父类中的，所有成员权限高于 ''private'' 的，都会变为 ''private''
 +===using 与继承===
 +  * 使用 ''using'' 可以在条件允许下，**在派生类中**改变继承成员的权限：
 +<code cpp>
 +struct Base
 +{   
 +    public:
 +        int pub;
 +    private:
 +        int pri;
 +    protected:
 +        int pro;
 +};
 +
 +struct Derived: public Base
 +{
 +    // inaccessiable 的成员（父类 Private 成员）无法修改权限
 +    public:
 +        // 修改继承的 Protected 成员权限为 public
 +        using Base::pro;
 +    private:
 +        // 修改继承的 public 成员权限为 为 private
 +        using Base::pub;
 +};
 +
 +int main()
 +{
 +    Derived d;
 +    // 修改后可访问
 +    d.pro;
 +    // 修改后无法访问
 +    d.pub;
 +}
 +</code>
 +<WRAP center round box 100%>
 +对派生类不可见的成员（基类中的 ''private'' 类型成员），''using'' 无法改变其权限
 +</WRAP>
 +
 +
 +==using 与成员函数==
 +  * ''using'' 关键字也可以作用于基类的成员函数（构造函数除外），使用方法：
 +<code cpp>
 +// 在派生类中使用
 +using Base::func;
 +</code>
 +  * 引入的是**函数名**：所有同名的函数都会被引入，在派生类中通过函数匹配规则来调用：比如上面的例子中：
 +<code cpp>
 +// 所有名字为 func 的函数都会被引入派生类
 +void func(int);
 +void func(int,int);
 +// 派生类中根据函数匹配调用
 +// ...
 +Derived d;
 +d.func(1); // 调用 func(int)
 +d.func(2,2); // 调用 func(int, int)
 +</code>
 +  * 如果派生类中存在同名函数的定义，那么会**隐藏**所有引入的，基类的同名函数：
 +<code cpp>
 +sturct Derived : public Base
 +{
 +    void func(int, int, int) {//...}
 +};
 +// 错误，无法找到匹配函数
 +d.func(1);
 +</code>
 +<WRAP center round box 100%>
 +这点同样适应于构造函数。通常情况下，如果派生类中没有引入新的数据成员，那么可以使用 ''using'' 直接 “借” 基类的构造函数逻辑使用。
 +但当派生类中定义了构造函数时，派生类的初始化则会调用派生类的构造函数。两者达到的效果相同，但的路径不同：
 +  * ''using Base::Cstr''：使用 ''Base::Cstr()'' 构造
 +  * 派生类中定义了构造函数时：通过 ''Derived::Cstr()'' -> 调用 ''Base::Cstr()'' 完成派生类对象的构造
 +</WRAP>
 +==using 与重写==
 +  * ''using'' 不会改变虚函数的修饰（''using'' 的优先级低于重写）
 +  * 如果希望使用 ''using'' 实现**改变权限下的重写**：
 +    * 最好的办法是使用虚函数的特性，对**特定的重载**进行重写（带函数签名的，比如 ''func(int)''，而不是 ''func''）
 +    * 也可以通过在派生类中使用函数隐藏来进行重写
 +===基类指针与容器===
 + C++ 可以通过多态（基类指针）可以（有限）实现容器存储以及访问不同类型的对象：
 +<code cpp>
 +struct Base
 +{   
 +    // 访问内容函数
 +    virtual double getValue() = 0;
 +    // 使用基类指针访问派生类时，释放堆资源必须声明虚析构
 +    virtual ~Base() = default;
 +};
 +
 +struct DerivedI: public Base
 +{
 +    DerivedI(int x):val(x) {}
 +    // 注意这里的 double，限制在这里
 +    double getValue() override { return val; };
 +    int val;
 +};
 +
 +struct DerivedD: public Base
 +{
 +    DerivedD(double x): val(x) {}
 +    double getValue() override { return val; };
 +    double val;
 +};
 +int main(int argc, char const *argv[])
 +{
 +    // 使用智能指针作为基类指针
 +    std::vector<std::shared_ptr<Base>> vec;
 +    
 +    // 使用 vec 通过 new 返回的指针，存储 Base 的不同派生对象
 +    vec.emplace_back(new DerivedI(1));
 +    vec.emplace_back(new DerivedD(3.14));
 +    
 +    for (auto &obj : vec)
 +    {
 +        std::cout << obj->getValue() << " ";
 +    }
 +    std::cout << std::endl;
 +    return 0;
 +};
 +</code>
 +<WRAP center round box 100%>
 +可以看出来这种实现是有局限性的：虚函数返回的是派生类的公共类型：''int'' 可以转换成 ''double''。如果这种公共类型不存在，
 +那么这种实现也是不可能的。
 +</WRAP>
 +===多重继承与虚继承===
 +  * 虚继承：以 ''virtual'' 的方式继承
 +<code cpp>
 +Class D1 : virtual public Base { .... };
 +</code>
 +  * 解决的问题：菱形继承带来的数据成员重复的问题，保证最终继承者的数据成员不会因为多重继承而翻倍。
 +===空基类优化===
 +==空类的大小为 1==
 +空类的大小被定义为 ''1''，是因为寻址的需求。假设存在一个该类类型的数组，则其寻址是基于起始地址 + 类大小 * 元素数量来计算的：
 +<code cpp>
 +ClassType a[2];
 +a[1] -> a[0 + 1] -> address(a[0]) + 1 * sizeof(ClassType)
 +</code>
 +这种情况下，如果空类大小为 ''0''，则会导致 ''a[0]'' 和 ''a[1]'' 的地址相同。C++ 不允许存在两个地址相同但逻辑上不同的单元。
 +==空类的问题以及传统解决方案==
 +有几个前提条件：
 +  * 成员函数不占用类的空间
 +  * 根据计算机的不同，类中元素占用空间不足字的，会进行内存对齐：比如空类 ''1'' 和 ''int'' 成员的组合，大小为 ''5'' 字节，但占用 ''8'' 字节空间
 +根据上述信息，因为这个 ''1'' 的空间占用，我们为上述组合付出的代价是空间占用翻倍。传统的解决方案是将函数放置到基类中，
 +进行继承。在这种情况下，编译器会进行空基类优化，忽略空基类的大小：
 +<code cpp>
 +struct Base { // some funcs ... }; // empty class
 + 
 +// obj = 4 bytes
 +struct Derived1 : Base
 +{
 +    int i;
 +};
 +</code>
 +== C++20 的解决方案==
 +上述解决方案的问题在于，public 继承的意义是描述 //is-a// 关系，但明显该类关系不是。C++ 20 提供了一种 ''no_unique_address'' 的类型
 +用于描述空类。被该类类型定义的空类大小为 ''0''。因此，相较于继承，我们可以将函数类直接作为数据成员放置到新类中调用，而不用付出额外的空间成本：
 +
 +<code cpp>
 +struct Empty {}; // empty class
 + 
 +struct X
 +{
 +    int i;
 +    [[no_unique_address]] Empty e;
 +};
 +</code>
  • 最后更改: 2024/11/18 03:59
  • ©2022 YGwiki.com