Problem with member and non-member binary operator in template class

[ghager]

Hi all,

I must be blind or stupid. Please consider the following code:

----
....
template <class T> class P;
template <class T> P<T> operator*(T,con st P<T>&);

template <class T>
class P{
private:
T d;
public:
P(int i=0);
P<T> operator*(T);
friend P<T> operator*<>(T,c onst P<T>&); // this is line 15
};

template <class T> P<T> operator*(T x,const P<T>& p)
{
return P<T>(x*p.d);
}

template <class T>
P<T>::P(int i) : d(i) {}

template <class T>
P<T> P<T>::operator* (T x)
{
return P<T>(x*d);
}

int main()
{
P<int> p(4),q,r;
q=3*p;
r=p*3;
return 0;
}
----

Compiling this code, e.g. g++ 4.0 says:

opp.cc:15: error: declaration of 'operator*' as non-function
opp.cc:15: error: expected ';' before '<' token

Intel 9.0 says:

opp.cc(15): error: function "P<T>::operator * [with T=int]" is not a
template
friend P<T> operator*<>(T,c onst P<T>&);
Mysteriously, when I interchange the friend declaration in P
with the declaration of the member operator*, everything
is fine. What's going on?

Thanks for any help,
bye,
Georg.

[Carlos Martinez Garcia]

I'm not an expert, but I think if operator is friend, it must not belong
to P when you define it (it must be operator*, and not P<T>::operator* )
ghager wrote:

Hi all,

I must be blind or stupid. Please consider the following code:

----
...
template <class T> class P;
template <class T> P<T> operator*(T,con st P<T>&);

template <class T>
class P{
private:
T d;
public:
P(int i=0);
P<T> operator*(T);
friend P<T> operator*<>(T,c onst P<T>&); // this is line 15
};

template <class T> P<T> operator*(T x,const P<T>& p)
{
return P<T>(x*p.d);
}

template <class T>
P<T>::P(int i) : d(i) {}

template <class T>
P<T> P<T>::operator* (T x)
{
return P<T>(x*d);
}

int main()
{
P<int> p(4),q,r;
q=3*p;
r=p*3;
return 0;
}
----

Compiling this code, e.g. g++ 4.0 says:

opp.cc:15: error: declaration of 'operator*' as non-function
opp.cc:15: error: expected ';' before '<' token

Intel 9.0 says:

opp.cc(15): error: function "P<T>::operator * [with T=int]" is not a
template
friend P<T> operator*<>(T,c onst P<T>&);
Mysteriously, when I interchange the friend declaration in P
with the declaration of the member operator*, everything
is fine. What's going on?

Thanks for any help,
bye,
Georg.

[ghager]

Carlos Martinez Garcia wrote:

I'm not an expert, but I think if operator is friend, it must not belong
to P when you define it (it must be operator*, and not P<T>::operator* )

In fact I have two operator* functions, one is a member with
one argument and one is a non-member with two arguments (the
original class type as second argument). So the compiler should know
when to select which, but obviously things get mixed up.

[Carlos Martinez Garcia]

ghager wrote:

Carlos Martinez Garcia wrote:

I'm not an expert, but I think if operator is friend, it must not belong
to P when you define it (it must be operator*, and not P<T>::operator* )

In fact I have two operator* functions, one is a member with
one argument and one is a non-member with two arguments (the
original class type as second argument). So the compiler should know
when to select which, but obviously things get mixed up.

Yes. You're right. I haven't see the second (non-member operator*)
I test it with g++ 3.3.6 and compiles ok

I'm sorry

[ghager]

Yes. You're right. I haven't see the second (non-member operator*)
I test it with g++ 3.3.6 and compiles ok

Yes, older compilers like gcc 3.3.X and SUN WS6 accept this code.
But all newer ones (PGI 6.0, Intel 9.1beta, gcc 4.0) generate
an error.

Another piece of information: If the class isn't a template, it works
fine.

Clueless :-(,
Georg.

[Thomas Tutone]

ghager wrote:

Hi all,

I must be blind or stupid. Please consider the following code:

template <class T> class P;
template <class T> P<T> operator*(T,con st P<T>&);

template <class T>
class P{
private:
T d;
public:
P(int i=0);
P<T> operator*(T);
friend P<T> operator*<>(T,c onst P<T>&); // this is line 15
I think you mean:

friend P<T> operator*(T, constP<T>&);
};

template <class T> P<T> operator*(T x,const P<T>& p)
{
return P<T>(x*p.d);
}

template <class T>
P<T>::P(int i) : d(i) {}

template <class T>
P<T> P<T>::operator* (T x)
{
return P<T>(x*d);
}

int main()
{
P<int> p(4),q,r;
q=3*p;
r=p*3;
return 0;
}
----

Best regards,

Tom

[ghager]

No, this is a friend function declaration in which the
friend is an appropriately typed function which
is not a template specialization (C++ standard
§14.5.3).

What I want to have is a friend that is an appropriately
typed function template specialization for each specialization
of the class template.

Bye,
Georg.