C++ 虚拟运营商<&书信电报；和模板

我正在尝试实现一种虚拟操作符您的目标不能仅通过模板来实现，因为取消引用

IBase*

会使您获得

IBase&

-模板实例化发生在编译时，编译器无法访问运行时类型

（动态分派仅在调用对象的成员函数时发生，并且二进制运算符不能是其右操作数的成员。）

---

因此，如果您将解除引用的

IBase*

传递给

操作符，则您的模板化操作符将永远不会被使用。您可以借助简单的模板装备（此外，这不会阻止反虚拟化）将其虚拟化

struct X{
虚拟std：：ostream&repr（std：：ostream&out）常数；
}
样板
std:：如果启用，则启用<
std：：是一样的吗<
std:：void\u t<
decltype（std:：declval（）.repr（std:：declval（））>，
void>：：值，
std:：ostream&>
操作人员
class IBase
{
public:
    IBase() {};
    virtual ~IBase() {};
};

template <typename T>
class Derived
    : public IBase
{
public:
    Derived(T data);
    template <typename U>
    friend std::ostream& operator<<(std::ostream& os, const Derived<U>& dt);
private:
    T data_;
};

template <typename T>
Derived<T>::Derived(T data)
    : IBase(),
      data_(data)
{
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const Derived<T>& dt)
{
    os << dt.data_;
    return os;
}

int _tmain(int argc, _TCHAR* argv[])
{
    IBase* base = new Derived<int>(5);

    std::cout << *base;
}

#include <iostream>
#include <string>
using namespace std;

class Base {
 public:
 virtual string toString() const {
   return "base";
 }
};

class Child : public Base {
 public:
  virtual string toString()  const {
   return "child";
  }

  friend ostream& operator<<(ostream& out, const Base& b);
};

ostream& operator<<(ostream& out, const Base& b) {
    out << b.toString();
    return out;
}

int main() {
    Child c;
    cout << c;
    return 0;
}

class IBase
{
public:
    IBase() {};
    virtual ~IBase() {};
    virtual std::ostream& output(std::ostream&) const = 0;
};

template <typename T>
class Derived
    : public IBase
{
public:
    Derived(T data);
    virtual std::ostream& output(std::ostream& os) const
    {
        os << data;
        return os;
    }
private:
    T data_;
};

std::ostream& operator<<(std::ostream& os, const IBase& dt)
{
    return dt.output(os);
}

struct X {
    virtual std::ostream& repr(std::ostream& out) const;
}

template <class X>
std::enable_if_t<
    std::is_same<
        std::void_t<
            decltype(std::declval<X>().repr(std::declval<std::ostream>()))>,
            void>::value,
    std::ostream&>
operator<<(X const& x)
{
    return x.repr(out);
}