StackOverflow2013

Note that there are some explanatory texts on larger screens.

plurals

PO
text
Body
copied!<p>Since it does not seem that this question is getting closed as exact duplicate, I will explain what your program does.</p> <pre><code>template <typename T> class test { int private_field; friend std::ostream& operator<<( std::ostream&, test<T> const & ); }; // ??? int main() { std::cout << test<int>() << std::endl; } </code></pre> <p>Templates are instantiated on demand (unless you explicitly instantiate them), that means that in this particular program <code>test</code> is instantiated only as <code>test<int></code>. When the compiler instantiates the template (because it was requested in <code>main</code>) it will process the template definition. At this point the behavior is similar to rewriting the code with the substituted type at the point of definition (in this case right before <code>main</code>):</p> <pre><code>class test<int> { friend std::ostream& operator<<( std::ostream&, test<int> const & ); }; </code></pre> <p>Now, if you look at the instantiated template, you can note that the <code>friend</code> declaration is befriending a non templated function. So in this particular program you can fill in the <code>???</code> with that particular function:</p> <pre><code>std::ostream& operator<<( std::ostream& o, test<int> const & t ) { return o << t.private_field; } </code></pre> <p>The problem here is that this is not easily extensible. The code of that <code>operator<<</code> is the same for <code>test<int></code> than it is for <code>test<double></code>, so there should be no need to <em>rewrite</em> the same function for all instantiating types!</p> <p>At this point there are two options, the first one is, as you have already identified, providing the definition of the function inside the class. The compiler will then process and define the function whenever the type is being instantiated. This solution creates non-templated functions on demand for each template instantiation (which is the option I would do, even with the quirks and strangeness of lookup here).</p> <p>Now, if you really want to avoid providing the definition inside the templates class, and you still want to provide a single implementation, then you have to resort to providing a templates <code>operator<<</code>. At this point you have two different options, you can declare <em>all</em> instantiations of the template (which I don't quite like, as it opens to too many others), or you can befriend a single specialization of the template function (cleaner regarding access, more cumbersome to write).</p> <p>The first case is:</p> <pre><code>template <typename T> class test { template <typename U> friend std::ostream& operator<<( std::ostream&, test<U> const & ); }; template <typename T> std::ostream& operator<<( std::ostream&, test<T> const & ) { ... } </code></pre> <p>The second case requires a couple of forward declarations:</p> <pre><code>template <typename T> test; template <typename T> std::ostream& operator<<( std::ostream&, test<T> const & ); template <typename T> class test { friend std::ostream& operator<< <T>( std::ostream&, const test<T>& ); }; template <typename T> std::ostream& operator<<( std::ostream&, test<T> const & ) { ... } </code></pre> <p>There is of course another option: do not declare <code>friend</code>s at all. Provide a <code>print(std::ostream&)</code> public function in your class that has the implementation, and provide a non-templated <code>operator<<</code> that just calls <code>print</code> on the second argument.</p>

Querying!

Guidance

An individual column

Larger individual text columns get their own page to allow for proper reading.

SQuiL has stopped working due to an internal error.

If you are curious you may find further information in the browser console, which is accessible through the devtools (F12).

Reload