"X is not a member of Y" even though X is a friend of Y?

Question

I am trying to write a binary tree. Why does the following code report error C2039, "'<<' : is not a member of 'btree<T>'" even though the << operator has been declared as a friend function in the btree class?

#include<iostream>
using namespace std;

template<class T>
class btree
{
public:
    friend ostream& operator<<(ostream &,T);
};

template<class T>
ostream& btree<T>::operator<<(ostream &o,T s)
{
    o<<s.i<<'\t'<<s.n;
    return o;
}

Answer 1

In

template <typename T>
class BTree
{
    //  ...
    friend std::ostream& operator<<( std::ostream&, T );
    //  ...
};

you're telling the compiler that there is a non template free function

std::ostream& operator<<( std::ostream&, Type )

for whatever type you happen to instantiate BTree over. But you never provide such a function. The definition you provide is for a member, but as a member function, your operator<< takes too many parameters.

Given that BTree is a generic type, it shouldn't provide the means of displaying its contained elements; that's up to the contained element type. What would make sense is something like:

template <typename T>
class BTree
{
    struct Node
    {
        //  ...
        void display( std::ostream& dest, int indent ) const;
    };

    //  ...
    void display( std::ostream& dest ) const;
    friend std::ostream& operator<<( std::ostream& dest, BTree const& tree )
    {
        tree.display( dest );
        return dest;
    }
};

template <typename T>
void BTree::display( std::ostream& dest ) const
{
    if ( myRoot == NULL ) {
        dest << "empty";
    } else {
        myRoot->display( dest, 0 );
    }
}

template <typename T>
void BTree::Node::display( std::ostream& dest, int indent ) const
{
    dest << std::string( indent, ' ' ) << data;
    if ( myLeft != NULL ) {
        myLeft->display( dest, indent + 2 );
    }
    if ( myRight != NULL ) {
        myRight->display( dest, indent + 2 );
    }
}

Answer 2

By declaring the operator friend, you tell the compiler to look for a function

ostream& operator<<(ostream &,T); 

where T is the exact same type the btree class template is instantiated with. (e.g. for btree<Node>, the actual signature would be ostream& operator<<(ostream &, Node); -- assuming you hace members i and n of type Node)

This function will have access to private and protected members (variables and functions) of the class btree<T> for all instances of T, but it is not actually a member of the class (as it would be without the friend keyword).

The operator definition you provide is for an operator that is a member of the template class btree, as if you have declared

template<class T> 
class btree 
{ 
public: 
  ostream& operator<<(ostream &,T);
}; 

This is due to the btree<T>:: prefix you included (that specifies which class the function/operator belongs to).

Since there is no corresponding operator declaration in the class (see the above description of the friend declaration), the compiler complains.

To fix it, you either

• keep the friend declaration, remove the btree<T>:: prefix and template<class T> from the operator defintion and change the second parameter type to btree<Type>&, where Type is one of the types you expect the btree template to be instantiated with (e.g. Node) -- then supply similar defintions for other such types as well.
• or remove the friend keyword from the declaration in the class and remove the T parameter from both the declaration and the definition as now the operator is supposed to work on the whole btree (which is implicitly supplied via *this).
• Alternatively, you can experiment with declaring the friend operator as a template, but that requires some more modifications: (read more about forward declaration)

template<class T> btree; // forward declaration of class btree

// forward declare operator (or move definition here)
template<class T>
ostream& operator<<(ostream &o, btree<T>& s);

// declare operator as template friend
template<class T>            
class btree            
{            
public:            
  friend ostream& operator<< <> (ostream &, bree<T>&);
  // note <> after operator name to denote template with no new template parameters
};

Note that above I assumed that you want to output the whole tree (that is invoke the operator<< on a btree object). It is not clear from the code you have whether this is your intention (class btree does not have members i and n). If not, and the type you want to invoke the << operator on is the actual template parameter of btree, then you don't need to change the second parameter of the templated operator from T, but there is also no need to declare it as friend of class btree as the operator is independent of btree. You do need to declare it as friend of the class whose members i and n you are accessing in the definiton of the operator (e.g Node above), if i and/or n is private in that class. The notion about losing btree<T>:: (or Node::) still applies as the operator does not belong to any class.

Couple more things, assuming you go with the friend declaration:

• The type of the second parameter to the operator should be btree<T>& (emphasis on &) as it is more efficient to pass a reference to the btree object than to copy the entire btree (or a shallow copy if you use pointers and go with the default copy-contructor)
• the second parameter should also be marked const, as (presumably) you do not want to change the btree object during output. Be aware that in this case you will need to mark certain non-changing methods in btree<T> as const as well to allow it to compile. (See the FAQ on const correctness)

EDIT'd a few times to make it clear and ensure correctness

Answer 3

A friend function is granted the same access to members of a class that members get, but it is not a member.

That's the whole point of the friend keyword, to give this access to non-members.

Since your operator<< doesn't use btree<T>, there's no reason to make it a friend of btree<T>.

So I think you meant

friend ostream& operator<<(ostream &, const mydata&);

inside class mydata.

Answer 4

Replace:

template<class T>
ostream& btree<T>::operator<<(ostream &o,T s)
{
    o<<s.i<<'\t'<<s.n;
    return o;
}

with:

ostream& operator<<(ostream &o, const mydata &s)
{
    o<<s.i<<'\t'<<s.n;
    return o;
}

As Ben Voight mentions, the error is telling you that this function is not a member of btree. Also, you seem to be defining that function for mydata exclusively, since it's expecting s and i members.

Answer 5

EDIT

Because it's a friend function, C++ is a bit weird. See, friend functions aren't actually defined in the class, they're defined in a different namespace. You have to provide an output function used by operator<< inside the class definition if you want it to use a templated member function.

The reason I suggest the following method (stream_out) is to demonstrate an easy way to do it in a way that makes it a member and doesn't mislead readers of your code, because it isn't a clever hack.

94% of the time you can use a clever hack such as has been suggested in the comments, but it does not answer the fundamental question: your 'friend' function is not a member of your class unless its body is given in the declaration, period, nothing else to say on the matter.

(What is the other 6% of the time, you ask, that this is not OK? copy constructor nonsense, CLI, and other unspeakable bumps in the night.)

If you absolutely must include it outside, as a member function, you would do something like...

template<class T>
class btree
{
  private:
    int i;
    int n;
    void stream_out(std::ostream& o);

  public:
    friend std::ostream& operator<<(std::ostream& o, btree<T> & me) {
        me.stream_out(o);
        return o;
    }
};

template <class T>
void btree<T>::stream_out(std::ostream& o)
{
    o << i << '\t' << n;
}

EDITED to clear up the summary a bit.