How does "std::cout << std::endl;" compile?

Question

Most IO stream manipulators are regular functions with the following signature:

std::ios_base& func( std::ios_base& str );

However some manipulators (including the most frequently used ones - std::endl and std::flush) are templates of the following form:

template< class CharT, class Traits >
std::basic_ostream<CharT, Traits>& func(std::basic_ostream<CharT, Traits>& os);

Then, how does the compilation of std::cout << std::endl; succeed given that the following example fails:

$ cat main.cpp 
#include <iostream>

int main()
{
    auto myendl = std::endl;
    std::cout << myendl;
}

$ g++ -std=c++11    main.cpp   -o main
main.cpp: In function ‘int main()’:
main.cpp:5:24: error: unable to deduce ‘auto’ from ‘std::endl’
     auto myendl = std::endl;
                        ^

It is clear that the context (in std::cout << std::endl;) helps the compiler to disambiguate the reference to std::endl. But what are the rules that govern that procedure? It looks like a real challenge for overloading resolution, which has to answer two questions at once:

Which specialization of std::endl<CharT, Traits>() does std::endl refer to?
Which function does the operator<< refer to?

Template argument deduction (1) should happen before overload resolution (2), but it seems that (at least some part of) (2) is required to be performed in order for (1) to succeed.

Somewhat related but no-way duplicate questions are:

None of those questions and neither answers to them address the workings of template argument deduction that should precede overload resolution but must be helped by the latter.

Follow-up question: How does overload resolution work when an argument is an overloaded function?

@πάνταῥεῖ This question is not a duplicate. It's not even that Dietmar Kühl's answer contains information requested in my very different question (it only states that "The compiler deduces the template arguments automatically" while I am curious how that deduction works). — Leon
@Leon Can you make up your arguments into your question why you think it's not clearly explained in Dietmar's or the other answers there please? I'd consider to reopen your question maybe. — πάντα ῥεῖ
@πάνταῥεῖ I already added those arguments in my edit (before the question was closed). — Leon
Well, start with a minimal reproducible example when asking. — πάντα ῥεῖ

aschepler aschepler · Accepted Answer · 2016-10-29T21:46:55

The operator<< in question is a member of std::basic_ostream:

namespace std {
    template <class charT, class traits = char_traits<charT> >
    class basic_ostream {
    public:
        basic_ostream<charT,traits>& operator<<(
          basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&));
        // ...
    };
}

Since the call is to std::cout << std::endl, or equivalently std::cout.operator<<(std::endl), we already know the exact instantiation of basic_ostream: std::basic_ostream<char, std::char_traits<char>>, aka std::ostream. So the member function of cout looks like

std::ostream& operator<<(std::basic_ostream<char, std::char_traits<char>>& (*pf)
    (std::basic_ostream<char, std::char_traits<char>>&));

This member function is not a function template, just an ordinary member function. So the question remaining, is can it be called with the name std::endl as an argument? Yes, initializing the function argument is equivalent to a variable initialization, as though we had written

std::basic_ostream<char, std::char_traits<char>>& (*pf)
    (std::basic_ostream<char, std::char_traits<char>>&) = std::endl;

How does "std::cout << std::endl;" compile?

4 Answers