оператор перегрузки << для шаблона класса

Question

давайте возьмем этот код для реализации оператора << для двух классов: </p>

#include <iostream>

using std::cout;
using std::endl;

class A
{
    int a1_;
public:
    A(int a1) : a1_(a1){}
    std::ostream& print(std::ostream& os) const
    {
        return os << "a1_ : " << a1_ << endl;
    }
};

class B
{
    int b1_;
    double b2_;
public:
    B(int b1,double b2) : b1_(b1),b2_(b2){}
    std::ostream& print(std::ostream& os) const
    {
        os << "b1_ : " << b1_ << endl;
        os << "b2_ : " << b2_ << endl;
        return os;
    }
};

std::ostream& operator<<(std::ostream& os, const A& in)
{
    return in.print(os);
}

std::ostream& operator<<(std::ostream& os, const B& in)
{
    return in.print(os);
}

int main(int argc,char* argv[])
{
    A myA(10);
    B myB(20,30.14);

    cout << myA << myB << endl;
    return 0;
}

Поскольку я ленивый, я хотел бы предоставить шаблонную версию оператора << вместо двух версий, как указано выше. Я могу сделать это легко заменив на: </p>

template< class T>
std::ostream& operator<<(std::ostream& os, const T& in)
{
    return in.print(os);
}

Пока все хорошо. Если у меня есть несколько классов, я могу реализовать оператор << за один раз. Проблемы начинаются, когда один из моих классов является шаблоном класса. Давайте возьмем предыдущий пример, но с шаблоном класса B: </p>

#include <iostream>

using std::cout;
using std::endl;

class A
{
    int a1_;
public:
    A(int a1) : a1_(a1){}
    std::ostream& print(std::ostream& os) const
    {
        return os << "a1_ : " << a1_ << endl;
    }
};

template <class T>
class B
{
    int b1_;
    T b2_;
public:
    B(int b1,T b2) : b1_(b1),b2_(b2){}
    std::ostream& print(std::ostream& os) const
    {
        os << "b1_ : " << b1_ << endl;
        os << "b2_ : " << b2_ << endl;
        return os;
    }
};


std::ostream& operator<<(std::ostream& os, const A& in)
{
    return in.print(os);
}

template <class T>
std::ostream& operator<<(std::ostream& os, const B<T>& in)
{
    return in.print(os);
}

int main(int argc,char* argv[])
{
    A myA(10);
    B<A> myB(20,myA);

    cout << myA << myB << endl;
    return 0;
}

Эта версия работает, и у меня ожидаемый результат, однако я предоставил две функции оператора << (по одной для каждого класса), давайте представим, что у меня есть 200 классов, которые уже реализуют общедоступный const ostream & print (ostream & os). Некоторые из них являются шаблонными классами (также с несколькими параметрами). </p>

Как мне написать шаблонную версию оператора << в этом сценарии? </p>

Спасибо за помощь.

Answer 1

То же, что и выше:

template< class T>
std::ostream& operator<<(std::ostream& os, const T& in)
{
    return in.print(os);
}

Однако такая перегрузка типа «поймать все» немного напоминает ловлю на динамит.Вы можете ограничить диапазон оператора всеми T, которые определяют подходящий «print» элемент, используя SFINAE (http://en.wikipedia.org/wiki/Substitution_failure_is_not_an_error):

template<int X, typename T>
struct enabler
{
    typedef T type;
};
template<class T>
typename enabler< sizeof(&T::print), std::ostream&>::type
operator << (std::ostream &o, const T &t)
{
    t.print(o);
    return o;
}

. Это фактически отключает оператор << при поиске подходящей перегрузки, если T имеет <em>нет участник print(std::ostream&)

Answer 2

Это, собственно, то, для чего Concepts предназначались.Вы можете эмулировать их с помощью Boost.Concepts на данный момент.

Однако в вашем решении есть одна проблема: Argument Dependent Lookup.

Когда вы используете оператор,оно должно быть:

• либо в текущей области (поиск будет излучаться наружу, чтобы рассмотреть все более и более глобальную область)
• , либо в пространстве имен одного из аргументов.

Однако, если вы определите перегрузку шаблона, он не сможет присутствовать в пространстве имен всех этих других классов.

Я предлагаю обман .

Если вы заключите std::ostream& в свой собственный класс, то в его пространстве имен вы можете указать все требуемые перегрузки операторов:

namespace X {

struct MyStream
{
  MyStream(std::ostream& o): _o(o) {}
  std::ostream& _o;
};

template <typename T>
MyStream& operator<<(MyStream& s, T const& t)
{
  t.print(s._o);
  return s;
}

} // namespace X

Затем вы можете добавить случайные перегрузки для распространенных типов:

inline MyStream& operator<<(MyStream& s, bool b)
{
  s._o << (b ? 'Y' : 'N');
  return s;
}

Не рискуя столкнуться с функциями, определенными в std.

Обратите внимание, что торгует переработкой иерархии классов (было бы неплохо иметь общую PrintableInterface) по сравнению с переработкойзвонки.Последнее можно сделать с помощью поиска и замены.