C++ 如何委托给实现类_C++ - Fatal编程技术网

C++ 如何委托给实现类

c++

C++ 如何委托给实现类,c++,C++,我有一个抽象基类节点，它派生自一个抽象接口类IObservable。有几个类实现了抽象的ioobservable：SingleObservable和MultiObservable 我想创建一个类observeNode，该类派生自基本节点类，并在其声明中指定用于实现IObservable接口的类我已经为IObservable中的每个纯虚拟方法添加了语句，引用了实现类中的方法，但是我仍然收到错误，说observeNode是一个抽象类，缺少notifyObservators（IObject*）的实

我有一个抽象基类

节点

，它派生自一个抽象接口类

IObservable

。有几个类实现了抽象的

ioobservable

：

SingleObservable

和

MultiObservable

我想创建一个类

observeNode

，该类派生自基本

节点

类，并在其声明中指定用于实现

IObservable

接口的类

我已经为

IObservable

中的每个纯虚拟方法添加了

语句，引用了实现类中的方法，但是我仍然收到错误，说observeNode
是一个抽象类，缺少notifyObservators（IObject*）
的实现
如果我使用

语句将参数

ioobject*

添加到

中，我会得到一个“预期的”；“before”（“令牌”错误）
我怎样才能解决这个问题
class IObservable {
  public:
    virtual ~IObservable() {};
    virtual void notifyObservers(IObject*) = 0;
};
class SingleObservable: public IObservable {
  public:
    virtual ~SingleObservable() {};
    void notifyObservers(IObject*) override { 
      //some implementaiton
    };
};
class MultiObservable: public IObservable {
  public:
    virtual ~MultiObservable() {};
    void notifyObservers(IObject*) override { 
      //some other implementaiton
    };
};

class Node: public IObservable {
  public:
    virtual ~Node() {};
};

class ObservableNode: public Node, public SingleObservable {
  public:
    virtual ~ObservableNode() {};
    using SingleObservable::notifyObservers;
    // using SingleObservable::notifyObservers(IObject*); // expected ';' before '(' token error

};


Node* node = new ObservableNode() // instantiating abstract class error, missing notifyObservers(IObject*) implementation

您的问题似乎是继承了仍然是抽象的节点
，这也导致引入了好的旧问题。当我这样更改您的代码时，错误消失了：
class Node: public IObservable {
  public:
    virtual ~Node() {};
    // ** Added an implementation here **
    void notifyObservers(IObject*) override { 
          //some other implementaiton
    };
};

class ObservableNode: public virtual Node, public virtual SingleObservable {
                          // ^^^^^^^              ^^^^^^^
  public:
    virtual ~ObservableNode() {};
    using SingleObservable::notifyObservers;
};

int main() {
    Node* node = new ObservableNode();
}

请参见。
描述一种解决方法，但可能这不是OP在此之后的内容。此外，答案中的方法可能会产生意外结果，例如，在调用节点->通知观察者（obj）
时：
请注意，在这个特定示例中，Node*Node=new
ObserveNode（）；
将意味着节点->通知观察者（obj）将调用
Node:：notifyobserver（IObject*）而不是
SingleObservable:：notifyObservers（IOObject*），可能是
意外，考虑到我们实例化了一个可观测节点对象
它指定使用singleobservate:：notifyobservators；

在OP的原始代码中，我们正遭受多重继承歧义，因为当节点
和单可观察
（和多可观察
）从IObservable
派生时，我们使用虚拟
继承
这意味着我们的w.r.t.继承，observeNode
to如下所示
 IObservable  IObservable
           |  |
        Node  SingleObservable
           \  /
       ObservableNode

然而，在此上下文中，我们可能希望对象的内存布局如下所示
       IObservable
           /  \
        Node  SingleObservable
           \  /
       ObservableNode

如果我们要纠正这一点，Node
可以保持抽象，并且以Node
为例调用Node->notifyObservators（obj）
将导致调用SingleObservable:：notifyObservators
，这可能是意料之中的
class Node: public virtual IObservable {
                // ↑↑↑↑↑↑↑
  public:
    virtual ~Node() {};
};

class SingleObservable: public virtual IObservable {
                            // ↑↑↑↑↑↑↑
  public:
    virtual ~SingleObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "SingleObservable::notifyObservers";
    };
};

struct DummyObj : public IObject {};

int main() {
    Node* node = new ObservableNode();
    DummyObj obj;
    node->notifyObservers(obj);  // SingleObservable::notifyObservers
}

有关菱形继承结构和虚拟继承的详细信息，请参见。
感谢所有建议！实现这些会给已经使用可观察的
实现的其他类带来许多其他问题，因此我选择以不同的方式解决它，包括一个实现实例和委派所有方法都适用于该方法
class IObject {
    public:
    virtual ~IObject() {};
};

class IObservable {
  public:
    virtual ~IObservable() {};
    virtual void notifyObservers(IObject*) = 0;
};

class SingleObservable: public IObservable {
  public:
    virtual ~SingleObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "Single\n";
      //some implementaiton
    };
};

class MultiObservable: public IObservable {
  public:
    virtual ~MultiObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "Multi\n";
      //some other implementaiton
    };
};

class Node: public IObservable {
  public:
    virtual ~Node() {};
    // void notifyObservers(IObject*) override { };
};

class SingleObservableNode: public Node {
  public:
    SingleObservableNode() {};
    virtual ~SingleObservableNode() {
        delete obs;
    };
    void notifyObservers(IObject* obj) override { 
        obs->notifyObservers(obj);
    }
    private:
     IObservable* obs = new SingleObservable();
};


class MultiObservableNode: public Node {
  public:
    MultiObservableNode() {};
    virtual ~MultiObservableNode() {
        delete obs;
    };
    void notifyObservers(IObject* obj) override { 
        obs->notifyObservers(obj);
    }
    private:
     IObservable* obs = new MultiObservable();
};

Node* node1 = new SingleObservableNode(); 
Node* node2 = new MultiObservableNode(); 

int main()
{
    node1->notifyObservers(nullptr);   // "Single"
    node2->notifyObservers(nullptr);   // "Multi"
   return 0;
}

类IOObject{
公众：
虚拟~IObject（）{}；
};
类IObservable{
公众：
virtual~IObservable（）{}；
虚拟对象（IOObject*）=0；
};
类SingleObservable:公共IObservable{
公众：
虚拟~SingleObservable（）{}；
void notifyObserver（IOObject*）重写{
std：：cout-notify-obj；
}
私人：
IObservable*obs=新的多可观测（）；
};
Node*node1=新的SingleObservableNode（）；
Node*node2=新的多观测节点（）；
int main（）
{
node1->notifyobserver（nullptr）；/“单个”
node2->notifyobserver（nullptr）；/“多”
返回0；
}
@Scheff-THX采用了它。不从IObservable
继承Node
肯定是另一种解决方案。您仍然可以将其作为答案发布。这确实解决了问题，谢谢！事实上，我确实希望节点定义中的IObservable接口注意，在这个特定示例中，Node*Node=new ObservableNode（）；
将意味着节点->通知观察者（obj）
将调用节点：：通知观察者（IObject*）
而不是单观察者：：通知观察者（IObject*）
，考虑到我们实例化了一个observeNode
对象，该对象使用SingleObservable:：notifyObservators；

指定

。OP可能希望在observeNode
中定义一个notifyObservators（IOObject*）
override，它明确地转发给SingleObservable:：notifyobservators（IObject*）
@Bascy您应该知道前面的评论。您仍在努力解决菱形歧义问题，可能会得到意外的结果……然后调用node->notifyobservators（obj）
将沿着vtable向下移动到observeNode:：notifyObservators（IObject*）
，然后从那里明确地移动到（通过转发）SingleObservable:：notifyObservators（IObject*）。
class Node: public virtual IObservable {
  public:
    virtual ~Node() {};
    void notifyObservers(IObject*) override { 
        std::cout << "Node::notifyObservers";
    };
};

class SingleObservable: public virtual IObservable {
  public:
    virtual ~SingleObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "SingleObservable::notifyObservers";
    };
};

class ObservableNode: public Node, public SingleObservable {
  public:
    virtual ~ObservableNode() {};
    // Non-ambiguous final override in ObservableNode.
    // We could use `override` specifier here, but we might as well
    // use `final`, if we are not expecting something to derive from ObservableNode.
    void notifyObservers(IObject* obj) final { 
        SingleObservable::notifyObservers(obj);
    };
};

struct DummyObj : public IObject {};

int main() {
    Node* node = new ObservableNode();
    DummyObj obj;
    node->notifyObservers(obj);  // SingleObservable::notifyObservers
}

class IObject {
    public:
    virtual ~IObject() {};
};

class IObservable {
  public:
    virtual ~IObservable() {};
    virtual void notifyObservers(IObject*) = 0;
};

class SingleObservable: public IObservable {
  public:
    virtual ~SingleObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "Single\n";
      //some implementaiton
    };
};

class MultiObservable: public IObservable {
  public:
    virtual ~MultiObservable() {};
    void notifyObservers(IObject*) override { 
        std::cout << "Multi\n";
      //some other implementaiton
    };
};

class Node: public IObservable {
  public:
    virtual ~Node() {};
    // void notifyObservers(IObject*) override { };
};

class SingleObservableNode: public Node {
  public:
    SingleObservableNode() {};
    virtual ~SingleObservableNode() {
        delete obs;
    };
    void notifyObservers(IObject* obj) override { 
        obs->notifyObservers(obj);
    }
    private:
     IObservable* obs = new SingleObservable();
};


class MultiObservableNode: public Node {
  public:
    MultiObservableNode() {};
    virtual ~MultiObservableNode() {
        delete obs;
    };
    void notifyObservers(IObject* obj) override { 
        obs->notifyObservers(obj);
    }
    private:
     IObservable* obs = new MultiObservable();
};

Node* node1 = new SingleObservableNode(); 
Node* node2 = new MultiObservableNode(); 

int main()
{
    node1->notifyObservers(nullptr);   // "Single"
    node2->notifyObservers(nullptr);   // "Multi"
   return 0;
}