Question

我有两个相互需要并继承自同一个类的类。我编译Seller.h，它编译得很好但是当我编译Buyer.h时，我从Seller.h那里得到错误。

所以当我编译Buyer.h时，我会收到错误，例如：

Seller.h:14:16: error: âBuyerâ has not been declared

  void addBuyer(Buyer*);

                ^
Seller.h:15:14: error: âBuyerâ was not declared in this scope
  std::vector<Buyer*>  getBuyers() const;

Seller.h:20:17: error: âOrderâ has not been declared
  void fillOrder(Order*);
             ^

它们是#included但仍然说不在范围内。

#ifndef SELLER_H
#define SELLER_H
#include "Entity.h"
#include <string>
#include <vector>
#include "Inventory.h"
#include "Buyer.h"
#include "Order.h"
class Seller : public virtual Entity
{
public:
        Seller(const std::string &, const std::string &, double=0.0);
        virtual~Seller(){}
        void addBuyer(Buyer*);
        std::vector<Buyer*>  getBuyers() const;
        void setInventory(Inventory*);
        Inventory* getInventory() const;
        virtual void list() const override;
        virtual void step() override;
        void fillOrder(Order*);
private:
        Inventory* inv;
        std::vector <Buyer*> buyers;
};
#endif

Buyer.h

#ifndef BUYER_H
#define BUYER_H
#include <string>
#include "Entity.h"
#include <queue>
#include "Order.h"
#include "Seller.h"
class Buyer : public virtual Entity
{
public:
        Buyer(const std::string &, const std::string &, double =0.0 );
        virtual ~Buyer(){}
        void addSeller(Seller *);
        std::queue <Seller *> getSellers() const;
        void addOrder(Order *);
        std::queue <Order*>  getOrders() const;
        virtual void list() const override;
        virtual void step() override;

private:
        std::queue <Order*>  orders;
        std::queue <Seller*> sellers;
};
#endif

Answer 1

Seller和Buyer之间存在循环依赖关系。这将永远不会起作用，因为编译器需要声明Seller才能编译Buyer ......但它还需要声明Buyer来编译Seller。

您可以改为声明您的类，因为您实际使用的只是指向这些类型的指针。例如：

#ifndef SELLER_H
#define SELLER_H
#include "Entity.h"
#include <string>
#include <vector>
#include "Inventory.h"
#include "Order.h"

// forward declaration of Buyer
class Buyer;

class Seller : public virtual Entity
{
public:
        Seller(const std::string &, const std::string &, double=0.0);
        virtual ~Seller(){}
        void addBuyer(Buyer*);
        std::vector<Buyer*>  getBuyers() const;
        void setInventory(Inventory*);
        Inventory* getInventory() const;
        virtual void list() const override;
        virtual void step() override;
        void fillOrder(Order*);
private:
        Inventory* inv;
        std::vector <Buyer*> buyers;
};
#endif

如果您有一个Buyer实例作为Seller的成员（即Buyer _buyer;），或者任何方法获取/返回了Buyer的实例，那么将被迫改变你的结构。由于您没有这个问题，因此前向声明就足够了。

顺便说一句，并且承认我不了解你的程序结构，当一个人在C ++程序中看到如此多的裸指针时，通常是一个坏迹象。您可以存储实例。您可以使用安全指针（shared_ptr和unique_ptr），具体取决于您的所有权语义。

例如，addBuyer可以轻松地使用Buyer&而不是指针。现在您不必担心无效指针。我假设您将这些添加到buyers向量中...但是如何保证这些指针在Seller实例的生命周期内保持有效？你不能;你受到任何一个叫addBuyer的人的摆布。

为什么不直接存储std::vector<Buyer>并在add方法中引用？副本的成本是否过高以至于无法保证这种设计？如果是，您是否可以使用shared_ptr？

类没有被声明，但它们被包括在内？

1 个答案: