Question

我正在尝试创建一个可用于模拟其他类的类。也许我正在寻找错误的关键词。基本上我希望PrimaryClass和类A是纯虚拟的。 DerivedClass和C来自各自的班级。 问题是，通过调用C中的继承类：DerivedClass，我没有覆盖纯虚拟PrimaryClass 。我知道这一点，但我不知道如何解决它。

我的印象是，C来自A它会起作用。如果我在

中更改C

virtual void DoFunThings ( C<T>* d ) {}

到A它有效，但重点是允许使用不同派生版本的A。

template <class T>
class A
{
public:  
    virtual void FunThings ( const A<T> &orig, A<T>* new_one ) = 0;   
    T thing{};
};


template <class T>
class C: public A < T >
{
public:
    virtual void FunThings ( const C<T> &orig, C<T>* new_one ) {}

};


template <class T>
class PrimaryClass
{
public:    
    virtual void DoFunThings ( A<T>* d ) = 0;
};



template<class T>
class DerivedClass: public PrimaryClass<T>
{
public:
    virtual void DoFunThings ( C<T>* d ) {}
};


int main ()
{
    DerivedClass<int> derived;

    return 0;
}

如果不可能这样做，怎么能用我想要的功能制作通用的面向对象的代码呢？

Answer 1

当然，您并未覆盖DoFunThings中PrimaryClass的{{1}}。你只是重载它。要覆盖它，它们必须具有相同的签名。您可以使用DerivedClass关键字在C ++ 11中轻松检测到此错误。

override

现在编译器（在我的案例中为Clang）将发出错误：

template <class T>
class A
{
public:  
    virtual void FunThings ( const A<T> &orig, A<T>* new_one ) = 0;   
    T thing{};
};

template <class T>
class C: public A < T >
{
public:
    virtual void FunThings ( const C<T> &orig, C<T>* new_one ) {}
};

template <class T>
class PrimaryClass
{
public:    
    virtual void DoFunThings ( A<T>* d ) = 0;
};

template<class T>
class DerivedClass: public PrimaryClass<T>
{
public:
    virtual void DoFunThings ( C<T>* d ) override {}
};

int main ()
{
    DerivedClass<int> derived;
}

Answer 2

解决方案是给予PrimaryClass和DerivedClass模板不是A＆amp; A的唯一数据类型。 C（问题中的int）但是对于A类和A类。 C.

template <class D>
class PrimaryClass
{
public:

    virtual void DoFunThings ( D* d ) = 0;
};



template<class D>
class DerivedClass: public PrimaryClass<D>
{
public:
    virtual void DoFunThings ( D* d ) {}
};


int main ()
{
    DerivedClass<C<int>> derived;

    return 0;
}

我有一个错误的假设，因为C来自A，它可以被使用。不知道我在哪里阅读/误解了它，但这会浪费很多时间。

Answer 3

您可以使用一些机械和模板以某种方式模拟虚拟功能模板，并获得与您正在寻找的东西非常接近的东西（可能）。
举个例子：

#include<type_traits>
#include<iostream>

template <class T>
class A {};

template <class T>
class B: public A < T > {};

template <class T>
class C: public A < T > {};

template <class>
class PrimaryClass;

template <typename T, template<typename> class U>
class PrimaryClass<U<T>>
{
    template<typename D, typename Z = U<T>>
    auto DoFunThings(int, D *d)
    -> decltype(static_cast<Z*>(this)->DoFunThingsOverride(d)) {
        return static_cast<Z*>(this)->DoFunThingsOverride(d);
    }

    void DoFunThings(char, A<T> *) {
        // do whatever you want if
        // derived class has not a
        // proper specialization
        std::cout << "PrimaryClass::DoFunThings" << std::endl;
    }

public:
    template<typename D>
    std::enable_if_t<std::is_base_of<A<T>, D>::value, void>
    DoFunThings ( D* d ) {
        DoFunThings(0, d);
    }
};

template<class T>
class DerivedClass: public PrimaryClass<DerivedClass<T>>
{
public:
    void DoFunThingsOverride ( C<T>* ) {
        std::cout << "DerivedClass::DoFunThings" << std::endl;
    }
};


int main ()
{
    DerivedClass<int> derived;
    B<int> b;
    C<int> c;

    derived.DoFunThings(&b);
    derived.DoFunThings(&c);

    return 0;
}

在wandbox中查看。

嵌套抽象基类的通用模板

3 个答案: