实现 Stream<T> 可以转换为 Stream<U> 其中 U 是 T 的基础

Question

我正在尝试实现一个通用的对象输入流。也就是说，实现的接口或轻量级代理。实现的细节是未知的，即我的库的用户可以编写自己的 protobuf 消息流，将其传递给我的库并返回，例如字符串流或任何其他流。我想保持流的通用接口，以便用户可以编写自己的转换并构建转换管道。

流的接口应该是这样的：

template <typename T>
class Stream {
public:
    T* input();
}

在每次调用时，input() 应返回流中的下一个对象，如果流为空，则返回空指针。

问题是如果T* 可转换为U*，我希望Stream<T> 可转换为Stream<U>。

我不成功的尝试是像这样使用指向实现的指针：

class StreamImplBase {
public:
    virtual void* input_raw() = 0;
}

template <typename T>
class StreamImpl: public StreamImplBase {
public:
    void* input_raw() final { return input(); }
    virtual T* input() = 0;
}

template <typename T>
class Stream {
    StreamImplBase* impl;
public:
    Stream(StreamImpl<T>* impl): impl(impl) {}
    T* input() { return static_cast<T*>(impl->input_raw()); }
}

StreamImpl<T> 的构造函数保证从input_raw() 返回的void* 是通过将T 转换为void* 获得的，因此static_cast<T*> 是安全的。

但是，如果我执行任何转换，则此陈述将不正确。也就是说，从StreamImpl<U> 构建Stream<T> 是不安全的，即使U* 可以转换为T*。

所以我的问题是，我该如何处理这个问题？

我看到了下一个可能性：

• 在流中存储一个转换器（例如std::function<T*(void*)>）并在每次转换时更新它。这似乎不必要地昂贵；

• 存储static_cast<U*>((T*)0)的结果并将这个结果添加到从input_raw()获得的指针上。这似乎是不必要的危险；

• 添加第二个模板参数OrigT并存储StreamImpl<OrigT>*而不是存储StreamImplBase*。这将限制该类的可能应用，我想避免这种情况；

• 使用dynamic_cast 不是一种选择，因为不能从void* 使用dynamic_cast。

还有其他可能吗？其他人如何实现这样的东西？

---

这是一个用例。假设我们有一个 protobuf 消息X。我希望这个工作：

Stream<X> stream = ...;
Stream<google::protobuf::Message> raw_stream = stream;

同样，我不知道Stream<X> 是如何实现的。我只知道它包含一个共享指针，指向生成消息的某个实现。

Answer 1

这个：

template <typename T>
class Stream {
public:
  T* input();
};

是一个有一个操作的对象，它接受0个参数并返回一个T*。

是这样的：

std::function<T*()>

诚然，您像 stream() 而不是 stream.input() 那样调用它。

使用第二种解决方案，如果U 是T 的基数，那么您可以将上述转换为std::function<U*()>。这解决了你的问题。

我个人认为在您的信息流名称和() 之间输入.input 不值得做很多工作。

其他人已经完成的类型擦除是最好的类型擦除。

Answer 2

当两个类在同一个函数中未知时，有一个 C++ 特性允许从派生类转换为基类：异常。当然，这是一种丑陋、丑陋的滥用，但它确实有效：

#include <type_traits>
#include <stdexcept>

class StreamImplBase {
public:
    virtual void toss_input() = 0;
};

template <typename T>
class StreamImpl : public StreamImplBase {
public:
    virtual T* input() = 0;
    void toss_input() override
    { throw input(); }
};

template <typename T>
class Stream {
    StreamImplBase* impl;
public:
    template <typename U,
        std::enable_if_t<std::is_convertible<U*, T*>::value>* = nullptr>
    explicit Stream(StreamImpl<U>* impl) : impl(impl) {}

    template <typename U,
        std::enable_if_t<std::is_convertible<U*, T*>::value>* = nullptr>
    Stream(const Stream<U>& str) : impl(str.impl) {}

    T* input() const
    {
        try {
            impl->toss_input();
        } catch (T* ptr) {
            return ptr;
        }
        throw std::logic_error("Stream logic is broken?");
    }
};

查看complete example use on coliru。这可以通过使用std::shared_ptr<StreamImpl<U>> 和std::shared_ptr<StreamImplBase> 来改善。