如何让单个接口返回不同的数据类型？

Question

简而言之，我想使用单个接口IProducer 创建一个对象IProduct。 IProduct 将具有不同的组件，具体取决于创建它的接口。然后IProduct 类将被IConsumer 接口使用。应该根据IProduct的派生类型使用正确的IConsumer类（我不想自己做类型检查）。

我本质上想使用策略模式（单个接口背后的不同行为），但增加了返回特定于所使用的派生接口的对象的能力。我想遵守 Open/Close 原则，并且在添加更多功能时不会更改任何这些现有类。

我想完成这样的事情（我确定某处的语法是错误的，但请耐心等待）：

class IProduct {
    public:
        int intData;
};

class ProductA : public IProduct {
    public:
        float floatData;
};

class ProductB : public IProduct {
    public:
        bool boolData;
};

class IProducer {
  public:
    virtual IProduct* produce(void) = 0;
};

class ProducerA : public IProducer {
  public:
    IProduct* produce(void) {
        return new ProductA;
    }
};

class ProducerB : public IProducer {
  public:
    IProduct* produce(void) {
        return new ProductB;
    }
};

class IConsumer {
    public:
        virtual void consume(IProduct* prod) = 0;
};

class ConsumerA : public IConsumer {
    public:
        void consume(IProduct* prod) {
        //I want to access the float!
    }
};

class ConsumerB : public IConsumer {
    public:
        void consume(IProduct* prod) {
        //I want to access the bool!
    }
};

void main() {

    IProducer* producer = ProducerFactory::create("ProducerA");

    IProduct* product = producer->produce();

    IConsumer* consumer = ConsumerFactory::create("ConsumerA");

    consumer->consume(product); //I would like the correct consumer to be used here to deal with the ProductA class
}

如果您认为有更好的方法来解决这个问题，我会全力以赴。感谢您的帮助！

Answer 1

您需要一个将IProduct 实现映射到正确的IConsumer 实现的注册表。基本上它只是地图的抽象：

class ConsumerRegistry
{
    std::map<size_t, std::shared_ptr<IConsumer>> m_consumers;

public:

    // we are not responsible for products, so lets allow plain ptrs here for more flexibility and less overhead
    std::shared_ptr<IConsumer> GetConsumer(IProduct* product)
    {
        auto it = m_consumers.find(typeid(product).hash_code());

        if (it == m_consumers.end())
            return nullptr;
        else
            return it->second;
    }

    template<typename P>
    void RegisterConsumer(std::shared_ptr<IConsumer> consumer)
    {
        m_consumers.emplace(typeid(P).hash_code(), consumer);
    }

    template<typename P>
    void UnregisterConsumer()
    {
        m_consumers.erase(typeid(P).hash_code());
    }
};

要么全局公开这个类（例如作为单例），要么在你需要的上下文中使用它。你像这样注册消费者：

reg.RegisterConsumer<ProductA>(new ConsumerA());
reg.RegisterConsumer<ProductB>(new ConsumerB());

我们还可以在 IConsumer 中包含一个 virtual void Register(ConsumerRegistry& reg) = 0; 方法，以便更安全地注册：

void ConsumerA::Register(ConsumerRegistry& reg, std::shared_ptr<IConsumer> self)
{
    IConsumer::Register<ProductA>(reg, self);
}

// Required for friendship, can be static:
template<typename T>
void IConsumer::Register(ConsumerRegistry& reg, std::shared_ptr<IConsumer> self)
{
    reg->RegisterConsumer<T>(self);
}

void ConsumberRegistry::RegisterConsumer(std::shared_ptr<IConsumer> consumer)
{
    consumer->Register(*this, consumer);
}

将Register() 和低级RegisterConsumer() 方法设为私有，并让ConsumerRegistry 和IConsumer 成为朋友。那么可以这样使用：

reg.RegisterConsumer(new ConsumerA());
reg.RegisterConsumer(new ConsumerB());

Answer 2

这是我正在考虑使用的解决方案。如有任何反馈，我将不胜感激。

我将使用访问者模式并像这样引入ProductVisitor 类：

class IProductVisitor {
public:
    explicit IProductVisitor() {}
    virtual ~IProductVisitor(){}
    virtual void visitA(ProductA* model) = 0;
    virtual void visitB(ProductB* model) = 0;
};


class ProductTypeVisitor : public IProductVisitor {
    public:
        typedef enum {Unknown, A, B} ProductType;
        explicit ProductTypeVisitor() : modelType(Unknown) {}
        virtual ~ProductTypeVisitor(){}
        virtual void visitA(ProductA* product) {
            modelType = A;
        }

        virtual void visitB(ProductB* product) {
            modelType = B;
        }

        ProductType getProductType(void) {
            return modelType;
        }

        ProductType modelType;
};

class IProduct {
    public:
        IProduct() : intData(3) {}
        virtual ~IProduct(){}
        int intData;
        virtual void accept(IProductVisitor* v) = 0;
};

class ProductA : public IProduct {
    public:
        ProductA() : IProduct(), floatData(5.5) { }
        virtual ~ProductA(){}
        float floatData;
        void accept(IProductVisitor* v) {
            v->visitA(this);
        }
};

class ProductB : public IProduct {
    public:
        ProductB() : IProduct(),boolData(false) { }
        virtual ~ProductB(){}
        bool boolData;
        void accept(IProductVisitor* v) {
            v->visitB(this);
        }
};

在制作我的工厂ConsumerFactor时，我将使用ProductTypeVisitor类来确定产品是什么类，动态正确地转换它（基于enum的状态），然后返回一个消费者用正确的产品初始化。

class ConsumerFactory {
public:
    explicit ConsumerFactory(void) {}

    IConsumer* createFromProduct(IProduct* product) {

        ProductTypeVisitor visitor;
        product->accept(&visitor);
        ProductTypeVisitor::ProductType productType = visitor.getProductType();

        IConsumer* consumerPtr;
        switch (productType) {
        case ProductTypeVisitor::A :
            consumerPtr =  new ConsumerA(dynamic_cast<ProductA*>(product));
            break;
        case ProductTypeVisitor::B :
            consumerPtr =  new ConsumerB(dynamic_cast<ProductB*>(product));
            break;
        default:
            std::cout << "Product type undefined. (throw exception)" << std::endl;
            break;
        }

        return consumerPtr;
    }

private:
    ProductTypeVisitor visitor;

};

最后，代码将如下所示：

IProducer* producer = new ProducerA;

IProduct* product = producer->produce();

ConsumerFactory factory;

IConsumer* consumer = factory.createFromProduct(product);

consumer->consume();

唯一指定的地方是ProducerA。就我而言，这是用户唯一应该指定的内容。此外，我将更改区域隔离为两个类，ConsumerFactory 和 IProductVisitor（一开始是非常小的更改）。

如果有人可以提供改进或建议，我会全力以赴！

Answer 3

这不是完整的解决方案（也许只是出于好奇），但您始终可以在编译时跟踪类型，并使用桥接模板调用将产品分派给正确的消费者。

#include <iostream>

template <class T>
class IProduct {
public:
  virtual ~IProduct() {}

  int intData;

  typedef T consumer;
};

class ConsumerA;

class ProductA : public IProduct<ConsumerA> {
public:
  float floatData;
};

class ConsumerB;

class ProductB : public IProduct<ConsumerB> {
public:
  bool boolData;
};

template <class P, class C>
void apply(P* product, C* consumer) {
  dynamic_cast<typename P::consumer*>(consumer)->consume(product);
}

template <class T>
class IConsumer {
public:
  virtual void consume(IProduct<T>* prod) = 0;
};

class ConsumerA : public IConsumer<ConsumerA> {
public:
  void consume(IProduct<ConsumerA>* prod) {
    //I want to access the float!
    std::cout << "ConsumerA" << std::endl;
    std::cout << dynamic_cast<ProductA*>(prod)->floatData << std::endl;
  }
};

class ConsumerB : public IConsumer<ConsumerB> {
public:
  void consume(IProduct<ConsumerB>* prod) {
    //I want to access the bool!
    std::cout << "ConsumerB" << std::endl;
    std::cout << dynamic_cast<ProductB*>(prod)->boolData << std::endl;
  }
};

int main(int argc, char* argv[]) {
  auto p_a = new ProductA;
  auto c_a = new ConsumerA;

  apply(p_a, c_a);

  auto p_b = new ProductB;
  auto c_b = new ConsumerB;

  apply(p_b, c_b);

  return 0;
}

Answer 4

我在尝试解决类似问题时发现了这个问题。我最终使用std::any（c++17 添加到语言中）来解决我的问题。单个接口可以返回一个std::any，您可以将其转换回底层类型（通过std::any_cast）。从广义上讲，std::any 就像在 void* 指针后面“隐藏”类型，但以类型安全的方式完成，具有完整的语言和编译器支持。

见：

• std::any: How, when, and why
• When should I use std::any
• 相关话题std::variant。