C++ 转换为“叔叔班”

Question

我有一个Wrapper<T> 模板类。

我有一个基类 A。

我有一个派生类 B：public A。

我想要的是将Wrapper<B> 存储在vector<Wrapper<A>> 中。

我知道这在技术上是不对的，因为 Wrapper<B> 不是 Wrapper<A> 的直接子类

See inheritance diagram

但不知何故，STL 允许 shared_ptr 这样做：

#include <memory>
#include <vector>
#include <iostream>

struct A
{
  A() {}
  virtual ~A() {}
  virtual void print() { std::cout << "A" << std::endl; }
};

struct B : public A
{
  B() {}
  virtual ~B() {}
  virtual void print() { std::cout << "B" << std::endl; }
};

int main()
{
  std::vector<std::shared_ptr<A>> v;

  v.push_back(std::make_shared<A>());
  v.push_back(std::make_shared<B>());

  for (auto &e : v)
    e->print();

  return 0;
}

我怎样才能为我的Wrapper<T> 类实现相同的结果？

这是非编译代码：

#include <vector>
#include <iostream>

template <class T>
struct W
{
};

struct A
{
  A() {}
  virtual void print() { std::cout << "A" << std::endl; }
};

struct B : public A
{
  B() {}
  virtual void print() { std::cout << "B" << std::endl; }
};

int main()
{
  std::vector<W<A>> v;

  v.push_back(W<A>());
  v.push_back(W<B>());

  for (auto &e : v)
    e->print();

  return 0;
}

最好， 皮埃尔

Answer 1

与 A 和 B 共享的 ptr 是不相关的类型。

shared ptr 所做的是提供一个转换构造函数。只要指针类型可以转换，它就接受 raw-pointer-to 和 shared-ptr-to。

shared ptr 类型会擦除如何进行最终销毁，并存储指针，所以这真的不难。

具体的工作方式取决于数据的存储方式和 Wrapper 的作用。

但是：

template<class T>
struct Wrapper {
  template<class U>
  Wrapper(Wrapper<U>);
};

基本上就是这样。也许一些 SFINAE 会得到更早的错误。

...

由于您实际上在 cmets 中添加了详细信息，因此您有：

template<class T>
struct RollbackElement : public T

作为Wrapper。答案是，不，你不能那样做。

你可以这样做：

template<class T>
struct RollbackElement : public std::any {
  operator T&() {
    return std::any_cast<T&>(*this);
  }
};

您可以在T 周围存储一个类型擦除包装器，而不是存储一个实际 T。

template<class T>
struct RollbackElement : private std::any {
  operator T&() {
    return *get();
  }
  operator T const&() const {
    return *get();
  }
  RollbackElement( T in ):
    std::any(std::move(in)),
    get_impl([](std::any& x)->T*{return std::any_cast<T*>(&x);})
  {}
  RollbackElement():RollbackElement({}) {}
  template<class U>
  RollbackElement( RollbackElement<U> const& o ):
    std::any( static_cast<std::any const&>(o) ),
    get_impl(o.get_impl)
  {}
  // note: due to quirks in `std::any`, a move ctor isn't safe
  T* operator->() { return get(); }
  T const* operator->() const { return get(); }
  T* get() { return get_impl(*this); }
  T const* get() const { return get_impl(const_cast<std::any&>(*this)); }
private:
  std::function<T*(std::any&)> get_impl = {};
};

加上你想要的任何增强。

这里的诀窍是你的存储空间，std::any，可以存储任何东西。

我们将如何从std::any 获取到T* 存储在get_impl 中。

当我们复制 RollbackElement 时，我们同时复制 any（不强制转换为具体类型）和 get_impl。如果另一个 Rollback 是 不同的 类型，我们依靠 std::function 的转换构造函数来为我们调整返回的指针。