Question

说我有以下抽象类：

class AbstractClass {
  public:
    AbstractClass() {}
    virtual ~AbstractClass() {}
    virtual void virtMethod()
    {
       printf( "%p\n", this );
    }
    void method()
    {
      printf( "%p\n", this );
    }
    ...
};

以下子课程：

class RawClass : public AbstractClass
{
  public:
    RawClass();
    ~RawClass();
    ...
};

class Wrapper : public AbstractClass
{
  public:
    Wrapper( AbstractClass* wrapee ) : _wrappee ( wrappee ) {}
    ~Wrapper() {};
    void virtMethod()
    {
      _wrappee->virtMethod();
    }
    ...

  private:
    AbstractClass _wrappee;
};

现在，请说我执行以下操作：

RawClass* r = new RawClass();
Wrapper* w = new Wrapper( r );
w->virtMethod(); // This prints the address of r
w->method(); // This prints the address of w

我希望调用w->method()的行为与调用w->virtMethod()的行为相同。但是，如果不method()虚拟并在Wrapper中编写一个仅仅调用RawClass::method()的实现，我就无法做到这一点。

我在这里明显遇到了一些设计问题，但无法找到一种方法来实现这一点，同时让RawClass和Wrapper对同一界面进行规定。

非常感谢任何帮助。

Answer 1

我认为你不应该从 AbstractClass 派生Wrapper而是像smart pointer一样重载->运算符，以便可以调用 AbstractClass 的方法

class Wrapper 
{
    AbstractClass* _rawClass;
  public:
    Wrapper( AbstractClass* wrapee ) : _rawClass( wrapee ) {}

    AbstractClass& operator* ()
    {
        return *_rawClass;
    }

    AbstractClass* operator-> ()
    {    
        return _rawClass;
    }

};

并称之为

   RawClass* praw = new RawClass();
   Wrapper wrap(praw);
   wrap->virtMethod();

如果你使用 shared_ptr

，Boost或C ++ 11已经为你做了这个

C ++中的包装类

1 个答案: