Re: Operator as non-function
saneman wrote:
James Kanze wrote:
On Feb 15, 2:51 am, saneman <y...@dd.com> wrote:
Victor Bazarov wrote:
saneman wrote:
In a .h file I have:
friend iterator operator + <> (difference_type i, const iterator&
it);
and outside the class I have:
template<class A>
hat_iterator<A> operator + (typename A::difference_type i,
const hat_iterator<A>& it) {
return hat_iterator<A>(it._pos + i, it._hat);
}
But when I compile I get:
error: declaration of ?operator+? as non-function
Is it a wrong definition?
Depends on the declaration. Post _complete_ code. Remove all
parts that are irrelevant, but keep the code compilable.
The below code:
template <class A>
class BOB {
private:
typedef BOB<A> iterator;
public:
typedef typename A::difference_type difference_type;
friend iterator operator + <> (difference_type i, const
iterator& it); };
Gives the error:
hat_iterator.h:11: error: declaration of ?operator+? as non-function
hat_iterator.h:11: error: expected ?;? before ?<? token
But both arguments have been typedefed so I cannot see where
the error is.
The problem is that the compiler doesn't know that the operator+
in question is (or might be) a template, and so interprets the <
after it as less than. You need a declaration of the operator+
in scope before defining the class. Something like:
template< class A > class BOB ;
template< class A > BOB<A> operator+(
typename BOB<A>::difference_type,
BOB<A> const& ) ;
before your class template definition.
I'm not sure, but I think your friend declaration should also
be:
friend iterator operator + <A> (difference_type i, const
iterator& it);
g++ accepts it either way, however. (I'm not sure what the
relationship between BOB and hat_iterator is, however.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient?e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S?mard, 78210 St.-Cyr-l'?cole, France, +33 (0)1 30 23 00 34
Ok this version below works as you recommended:
template< class A > class BOB;
template< class A >
BOB<A> operator+(typename BOB<A>::difference_type, BOB<A> const& );
template <class A>
class BOB {
private:
typedef BOB<A> iterator;
public:
typedef typename A::difference_type difference_type;
friend iterator operator + <> (difference_type i, const
iterator& it);
};
But I don't understand the first 3 lines.
The first 3 lines are _declarations_. They tell the compiler that
there will be (at some point) definitions of a class template BOB
with one type-argument, and a function template for 'operator+'
with certain arguments and the template type-argument. The main
reason is to declare the names (stake the claim, so to speak) and
make them belong to the global namespace.
Any subsequent use of the name 'BOB' or the operator+ *with*
template argument list (even if it's empty) would mean those are
referring to the previously declared names that live in the global
namespace.
In Bjarne Stroustrup C++PL
C.13.2 page 854 he writes the following example:
template <class T> class Matrix;
template <class T> class Vector {
T v[4];
public:
friend Vector operator *<> (const Matrix<T>&, const Vector&);
};
So it seems that it should not be necessary to declare the operator
as a template operator.
It is entirely possible that the requirements have changed since
the time of publishing of the copy you have. The name lookup rules
are not simple and in some cases, especially with templates, you
need to have the template declaration in the scope before you can
refer to it. I do not remember if declaring an instantiation of
a template function a friend is one of those cases.
I have C++ Templates by David Vandevoorde, but there is no info on
this special rule, is there some documentation on the theory behind
this example?
The Standard.
V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask