0

我有一个具有以下类继承的现有项目

class Base
{
public:
    Base();
    virtual ~Base();    
    void    SetID(unsigned short);
    virtual inline unsigned short GetID();
    protected:      
    unsigned short  id;
};


class Generic : public Base {
public:
        Generic(const char  *in_name);
        const   char* GetName()                 { return name; }

    protected:  
        char    name[30];
};

class Actor : public Generic
{
public:     
    Actor(const char    *in_name);
    ~Actor();   
    void DoSomething(const char* str);   
};

现在我创建了一个单独的项目，如果我想提供一个必须实现的接口才能使用该功能 - 我计划将该项目重用于其他实现。

class MyInterface
{
    public:     
        virtual ~MyInterface() {} 

        // Our methods that need to implemented
        virtual const char* GetName() = 0;      
        virtual void DoSomething(const char* str) = 0;
        virtual unsigned short GetID() = 0;
};

现在我只是想将它与我的演员类一起使用，例如演员类：public Generic，public MyInterface

但是它无法编译

'const char *MyInterface::GetName(void)' : is abstract see declaration of     'MyInterface::GetName'
'unsigned short MyInterface::GetID(void)' : is abstract see declaration of 'MyInterface::GetID'
error C2385: ambiguous access of 'GetName'
could be the 'GetName' in base 'Generic'
or could be the 'GetName' in base 'MyInterface'

问题可能是 GetName 已经在 Generic 中实现，而 GetID 已经在 Base 中实现 - 所以在子类 Actor 中实现接口是不可能的，因为编译器不够聪明，无法意识到已经有这些方法的实现。

但是，我找到了一种解决方法-但是为此，我必须扩展actor类的标头，这不是一件好事-我想知道是否有另一种方法-我的解决方法是

class Actor : public Generic, public MyInterface
{
public:     
    Actor(const char    *in_name);
    ~Actor();   
    void DoSomething(const char* str);   
    const char* GetName() { return Generic::GetName(); };
    inline unsigned short GetID() { return Base::GetID(); };
};

现在这显然不适用于可变参数方法，我必须实现现有方法并再次委托给父级 - 有更好的解决方案吗？

编辑为了澄清 - 类基础，通用和演员存在于其他人管理的另一个项目中，对这些的修改应该非常有限。- 我创建了一个单独的项目，它创建了一个静态 LIB - 将这些函数与演员类结合使用 - 我创建了一个接口，在我自己的项目中没有任何依赖关系，并为其他项目提供了一个可重用的库，这只是需要实现这个接口。

4

1 回答 1

1 
class Base
{
protected:      
    unsigned short  id;
public:
    void SetID(unsigned short);
    virtual inline unsigned short GetID() { return id; }
    virtual ~Base() {}
    Base(): id() {}
};


class Generic 
    : public Base
{
protected:  
    char    name[30];
public:
    const char* GetName() { return name; }
    Generic(const char* in_name): name() {}
};

class Actor
    : public Generic
{
public:     
    void DoSomething(const char* str) {}

    ~Actor() {}
    Actor(const char* in_name)
        : Generic( name )
    {}
};

class MyInterface
{
public:     
    // Our methods that need to implemented
    virtual const char* name() const = 0;      
    virtual int id() const = 0;
    virtual void doSomething( const char* str ) = 0;

    virtual ~MyInterface() {} 
};

template< class TpBase >
class MyInterfaceOn
    : public virtual MyInterface
    , public TpBase
{
public:
    typedef TpBase Base;

private:
    MyInterfaceOn& mutableSelf() const
    { return *const_cast<MyInterfaceOn*>( this ); }

public:
    const char* name() const { return mutableSelf().Base::GetName(); }
    int id() const { return mutableSelf().Base::GetID(); }
    void doSomething(const char* str) { Base::DoSomething( str ); }

    MyInterfaceOn( char const name[] )
        : Base( name )
    {}
};

class MyActor
    : public MyInterfaceOn< Actor >
{
public:
    MyActor( char const name[] )
        : MyInterfaceOn< Actor >( name )
    {}
};

int main()
{
    MyInterface const&  actor   = MyActor( "NN" );
}
于 2012-06-19T01:12:32.863 回答