Приспадане на тип шаблон за манипулатори на поток

endl е манипулатор, т.е. това е неразрешен тип функция. Има няколко претоварвания и приспадането на типа не може да реши кое искате.

По-конкретно, ето как изглежда endl (в GNU libc++):

/**
 *  @brief  Write a newline and flush the stream.
 *
 *  This manipulator is often mistakenly used when a simple newline is
 *  desired, leading to poor buffering performance.  See
 *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/bk01pt11ch25s02.html
 *  for more on this subject.
*/
template<typename _CharT, typename _Traits>
  inline basic_ostream<_CharT, _Traits>&
  endl(basic_ostream<_CharT, _Traits>& __os)
  { return flush(__os.put(__os.widen('\n'))); }

Актуализирано И така, проблемът е, че компилаторът не може да изведе кой екземпляр на endl ще подадете (това е неразрешено претоварване). Може да заобиколите това, като вместо това направите static_cast<ostream&(*)(ostream&)>(endl).

Разбира се, това не е удобно. Ето една проста корекция: http://liveworkspace.org/code/2F2VHe%241

#include <iostream>
using std::cout;
using std::endl;

class Foo : public std::ostream
{
    public:
        template<typename T>
        Foo& operator<<(T&& t) {
            cout << std::forward<T>(t);
            return *this;
        }

        typedef std::ostream& (manip)(std::ostream&);

        Foo& operator<<(manip& m) {
            cout << m;
            return *this;
        }
};

int main() {
    Foo foo;
    foo << "Hello World"; // perfectly fine
    foo << endl; // everything is fine

    return 0;
}

Проблемът е, че endl е манипулатор, дефиниран като функционален шаблон. Параграф 27.7.1 от стандарта C++11 определя неговия подпис:

template <class charT, class traits>
basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os);
template <class charT, class traits>

Освен това, съгласно параграф 13.3.1 относно разрешаването на претоварване:

Във всеки случай, когато даден кандидат е шаблон на функция, специализациите на шаблон на кандидат-функция се генерират чрез дедукция на аргумент на шаблон (14.8.3, 14.8.2). След това тези кандидати се обработват като кандидат функции по обичайния начин.

Вашият operator << е дефиниран като шаблон и компилаторът трябва да изведе типа на T. Как обаче компилаторът може да разбере коя инстанция на endl имахте предвид? Как може да изведе аргументите на шаблона charT и traits? Няма нищо друго във вашето обаждане до operator <<, от което да може да се заключи.

Имате два изхода от този проблем. Или прехвърляте типа endl изрично, за да кажете на компилатора кое претоварване да бъде избрано:

foo << (std::ostream& (*)(std::ostream&))endl;

Или, както направихте, създавате претоварване на operator <<, което приема функция с този специфичен подпис. Вашият компилатор сега ще го избере:

Foo& operator<<(ostream& (*f)(ostream&)) 
{
    return *this << f;
}

В тази дефиниция на функция няма неяснота какво е f: нейният тип е точно дефиниран. Тук обаче бъдете внимателни: тази функция вероятно не прави това, което очаквате! Всъщност той просто продължава да се извиква, генерирайки безкрайна рекурсия!

Следователно това твърдение:

[...] забележете, че всъщност извиквам другата си реализация на метода:

Е неправилно: вие не извиквате другата реализация на метода, вие продължавате да извиквате същата функция отново и отново.