c++类父类模板化template＜class T＞ class Derived:public T{}

ゝ一世哀愁。 2022-11-13 04:16 103阅读 0赞

第一次看到这个是懵逼的：  
后来发现是 **基类模板**  
https://zhuanlan.zhihu.com/p/106672814?utm\_source=wechat\_session

template<typename Parent>
    class FrameInternal : public Parent{ 
    public:
        typedef std::shared_ptr<FrameInternal> Ptr;
        FrameInternal(const Frame::Ptr &parent_frame, char *ptr, size_t size, size_t prefix_size)
                : Parent(ptr, size, parent_frame->dts(), parent_frame->pts(), prefix_size) { 
            _parent_frame = parent_frame;
        }
        bool cacheAble() const override { 
            return _parent_frame->cacheAble();
        }
    private:
        Frame::Ptr _parent_frame;
    };
    
    简化一下变成下面这种方式
    
    
    class A{ 
    A(){ }
    ~A(){ }
    }
    
    class B{ 
    B(int x):a(x){ }
    ~B(){ }
    private:
    int a;
    }
    
    class C{ 
    C(int a ,char ):a(a),b(b){ }
    ~C(){ }
    private:
    int a;
    char b;
    }
    template<class T>
    class Derived:public T{ 
    public:
        Derived():T(){ cout<<"Derived founed"<<endl;}
        Derived(int a):T(a){ cout<<"Derived founed"<<endl;}
         Derived(int a,char b):T(a,b){ cout<<"Derived founed"<<endl;}
         //上述很麻烦吧
         template<typename ...ArgsType>
        Derived(ArgsType &&...args):T(std::forward<ArgsType>(args)...){ }
        //这样是不是更加简单了呢
    };
    这种方式呢可以减少代码，通过构造函数来确定不同的父类,通过三个不同的构造就可以确定三个不同的父类
    Derived<A> a;
    Derived<B> b;
    Derived<C> c;
    实例化的时候分别调用三个不同的构造函数

一个类模板不仅可以从另一个类模板中导出，也可以从一个普通类导出，当然普通类也可以继承一个模板类；
    也就是说，普通类和模板类可以构成四种继承关系。
    https://zhuanlan.zhihu.com/p/106672814?utm_source=wechat_session

class Box { ...};
    
    class Box : public Apple { ...};
    
    class Box : public Orange { ...};
    
    class Box : public Banana { ...};
    template<class T>
    class Box:public T{ 
    //内部通过构造函数进行区分即可
    //具体看上面的例子
    }
    ......