Friend operator override for c++ class templates

Question

Entire test program.  When I change the operator from either + or - to *, I get compile errors.  Any ideas?
#include "stdafx.h"
#include <iostream>
using namespace std;
template <typename T>
class mjt {
public:
 mjt();
 friend mjt<T> operator + <>(const mjt<T>& ls, const mjt<T>& rs);
 friend mjt<T> operator - <>(const mjt<T>& ls, const mjt<T>& rs);
template <typename T>
mjt<T>::mjt() { }
template <typename T>
mjt<T> operator +(const mjt<T>& ls, const mjt<T>& rs) {
 mjt<T> result = ls;
 // Magic happens here
 return result;
template <typename T>
mjt<T> operator -(const mjt<T>& ls, const mjt<T>& rs) {
 mjt<T> result = ls;
 return result;
int _tmain(int argc, _TCHAR* argv[]) {
 mjt<int> set1, set2, set3;
 set3 = set1 + set2;
 set3 = set1 - set2;
 char ans;
 cin >> ans;
 return 0;

Answer 1

I think that the most acceptable answers can be found in Standards.
Intuitively,
    friend mjt<T> operator * < > ( const mjt<T> & ls, const mjt<T> & rs );
and
    friend mjt<T> operator * <T> ( const mjt<T> & ls, const mjt<T> & rs );
are similar. They stipulates that only the template implementation of
operator *, such as
    template <typename T>
    mjt<T> operator * ( const mjt<T> & ls, const mjt<T> & rs )
will be the friend of mjt, but only if the types
T of the mjt class and operator * are the same. Therefore the operator made for
<int> type will be friend for mjt<int>, but not for
mjt<float>.
Additionally, the non-template operators, if any, such as the explicitly written
    mjt<int> operator * (const mjt<int>& ls, const mjt<int>& rs)
will not be friends.
In the other variant where the friend declaration includes the
‘template’ keyword:
    template< typename T >
    friend mjt<T> operator * <T> ( const mjt<T>& ls, const mjt<T>& rs );
the T type denotes any type, which can be different from the homonymous type
T that appeared before in class declaration (template< typename T > class mjt …). To avoid confusion, you can write with the same effect:
template< typename T >
class mjt
    template< typename T2 >
    friend mjt<T2> operator * ( const mjt<T2> & ls, const mjt<T2> & rs );
This declares that the operator * of some type, such as
<int>, will be friend for mjt class of any type, not only
mjt<int>, but also for mjt<float>, mjt<int*>, mjt<string>, etc.
I hope that the Standards stipulate the same things.