Question

我想了解Foo<Derived>到Foo<Base>之类的转化。例如，如果我有以下代码段（长，抱歉）：

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

class Base
{
public:
  virtual void print() const = 0;
  virtual void print() = 0;
};

class Derived : public Base
{
public:
  virtual void print() const override { std::cout << "Derived::print const\n"; }
  virtual void print() override { std::cout << "Derived::print\n"; }
};

template <typename R>
class BasePtr
{
public:
  BasePtr() : ptr_(std::make_shared<R>())
  {
  }

  void print() const
  {
    ptr_->print();
  }

private:
  std::shared_ptr<R> ptr_;
};

/* Takes const shared ptr */
void takesConstSharedPtr(const std::shared_ptr<Base>& base)
{
  base->print();
}

void takesConstSharedPtrConst(const std::shared_ptr<const Base>& base)
{
  base->print();
}

/* Takes non-const shared ptr */
void takesSharedPtr(std::shared_ptr<Base>& base)
{
  base->print();
}

void takesSharedPtrConst(std::shared_ptr<const Base>& base)
{
  base->print();
}

/* Takes base ptr class */
void takesBase(BasePtr<Base>& base)
{
  base.print();
}

void takesBaseConst(BasePtr<const Base>& base)
{
  base.print();
}

/* Takes const base ptr class */
void takesConstBase(const BasePtr<Base>& base)
{
  base.print();
}

void takesConstBaseConst(const BasePtr<const Base>& base)
{
  base.print();
}

int main()
{
  std::shared_ptr<Derived> ptr = std::make_shared<Derived>();
  BasePtr<Derived> basePtr;

  // Works!
  takesConstSharedPtr(ptr);
  takesConstSharedPtrConst(ptr);

  // Does not works...
  takesSharedPtr(ptr);
  takesSharedPtrConst(ptr);

  takesConstBase(basePtr);
  takesConstBaseConst(basePtr);

  takesBase(basePtr);
  takesConstBase(basePtr);
}

我在main函数的最后6个调用中得到编译错误，但前两个调用没有编译错误。如果我注释掉最后6个调用，我可以成功编译并获得预期的输出：

Derived::print
Derived::print const

这里发生了什么？为什么shared_ptr<Derived>能够转换为const shared_ptr<Base>和const shared_ptr<const Base>，而不是非const版本？另外，如何编写BasePtr以便能够模仿shared_ptr的行为？

我得到的编译错误如下：

'void takesBase(BasePtr<Base> &)': cannot convert argument 1 from 'BasePtr<Derived>' to 'BasePtr<Base> &'

及其组合。

Answer 1

你可能认为某种BasePtr<Derived>引用在某种程度上可以简单地转换为BasePtr<Base>引用，但事实并非如此。这两种类型指的是完全不相关的类，它们之间没有继承关系。它们的模板参数可能，但两个模板参数之间的关系与实例化模板之间的关系没有任何关系。

设计shared_ptr的人知道这一点，并且仍然希望shared_ptr像常规指针一样可用，并且如果他们指向的东西具有父/派生关系，则看似自动转换。

因此，它们不是自动转换，而是由定义为::std::shared_ptr成员的特殊模板转换构造函数处理。这些创建了一个全新的shared_ptr，指向基类型的对象。这个新对象是临时的，因此您无法将其作为非const引用参数传递。

以下是您为BasePtr课程执行此操作的方法，但这很简单。查看shared_ptr的代码，它会查找许多边缘情况，其中允许或不允许进行转换（指向数组的指针与指向单个对象的指针是其中很大一部分），我和＃ 39;我不在这里。

template <typename T>
class BasePtr {
  public:
   BasePtr() : ptr_(new T) { }

   // This conversion constructor will fail if other.ptr_ cannot be
   // assigned to ptr_ without any explicit conversion.
   template <typename U>
   BasePtr(const BasePtr<U> &other) : ptr_(other.ptr_) { }

   // You would also need a converting version of operator = that
   // was written in much the same way.
};

另外，如果你考虑一下，你想要发生的事情也不适用于常规指针。

class Base {
};

class Derived : public Base {
};

void foo(Base *&baz)
{
}

void bar(Base * const &qux)
{
}

void trivially_works(Derived *&d)
{
}

void testing()
{
    Derived *d = new Derived;
    foo(d); // Failed with a compiler error, for same reason as BasePtr<Base> &.
    bar(d); // Works for same reason as const BasePtr<Base> &
    trivially_works(d); // And this works because you're passing a reference to d, not a temporary.

    Base *b = d; // Works of course
    foo(b); // And now this works because it's a reference to b, not a temporary.
}

Answer 2

了解模板的一个重要事项是它们本身不是一个类，除非在定义中明确说明，否则它们之间没有关系

template<typename T> class Foo; // not a class, only a template to make a class from
typedef Foo<Bar> FooBar; // an entirely new class with no relationships

即使我们有基类BarA和子类BarB也知道这一点。Foo生成的任何类仍然是一个新类，所以Foo<BarA>和{{1仍然是完全新的类，并且彼此不相关，因此在重新解释转换之外，它们之间的转换不会很好，这是不建议的。

编辑：有关您尝试做什么的更多信息

允许这种转换需要做的是模板转换功能，例如，未经测试的尝试

Foo<BarB>

再次，未经测试，我不知道它可以与shared_ptr一起使用，但它是在模板类型之间进行转换的一般想法

从Foo <derived>到Foo <base />的转换

2 个答案: