Overloading + operator on generic class

Hi all. I'm trying to overload the + operator in a forest class, a forest being a collection of trees, and the + operator is supposed to combine two forests into one. I have the following code as my class definition:

Code:

template<typename NODETYPE>
class Forest
{


    public:
        
        friend Forest& operator+<>(Forest&, Forest&);
        friend ostream& operator<<<>(ostream&, const Forest&);
        friend istream& operator>><>(istream&, Forest&);
        Forest();
        Forest( const Forest& otherForest);
        ~Forest();
        void nodes(int&) const;

    private:
        ForestNode<NODETYPE> *root;

        ForestNode<NODETYPE> *getNewNode( const NODETYPE &);
};

The following is my implementation of operator+:

Code:

template<typename NODETYPE>
Forest& operator+<>(Forest& f1, Forest& f2)
{
    f3 = new Forest();
    f3.root = *f1.*root;
    f3.root.sibling = *f2.*root;
    *f1.root = 0;
    *f2.root = 0;
    return f3;
}

I get the following error on compile:

|28|error: expected constructor, destructor, or type conversion before '&' token|
line 28 refers to the signature of my operator+ implementation.

I think to correct it i am supposed to add <NODETYPE> to the return type, giving:

Code:

template<typename NODETYPE>
Forest<NODETYPE>& operator+<>(Forest& f1, Forest& f2)
{
    f3 = new Forest();
    f3.root = *f1.*root;
    f3.root.sibling = *f2.*root;
    *f1.root = 0;
    *f2.root = 0;
    return f3;
}

But that gives me the following errors:


|28|error: declaration of 'operator+' as non-function|
|28|error: missing template arguments before '&' token|
|28|error: 'f1' was not declared in this scope|
|28|error: missing template arguments before '&' token|
|28|error: 'f2' was not declared in this scope|

Can anyone help me with this? I'd be very very thankful.

1) Take out extraneous <> characters in the friend declarations

2) The definition of the operator+() will look like

Code:

template<typename NODETYPE>
Forest<NODETYPE> operator+(Forest<NODETYPE>& f1, Forest<NODETYPE>& f2)
{
    Forest<NODETYPE> f3;   //   don't dynamically allocate

}

3) It is conventional that operator+() return a separate object (not a reference) and that the arguments supplied to it are const.

I don't think you need the <> after the + and before the (). But then I have not done a template overloaded operator before.

Also wouldn't it be:

Code:

Forest<NODETYPE>& operator+(Forest<NODETYPE>& other,)

I have used it in this format but not passing two parameters.