function template specialization

[aaragon]

Hi... after trying several things with some templated code I decided
to ask the experts a couple of things. I have the following class
template:

template<class A>
class Expr {
A a_;
public:
... // some public functions
...
friend inline std:stream& operator<<(std:stream& os, const
Expr<A>& e) {
os<<e.a_();
return os;
}
};

operator<< works just fine, but then I wanted to have the operator<<
with different behaviors depending on the template parameter. So, I
tried the following inside the class:
// declaration inside the class
friend std:stream& operator<<<A>(std:stream& os, const Expr&
e);

and defining the function outside:
template <class A>
inline std:stream& operator<<(std:stream& os, const Expr<A>&
e) {
os<<e();
return os;
}

Then I got just too many errors because of ambiguous calls and others
like:
cppblas.hpp:862: error: template-id 'operator<< <UnOp<Vector<double>,
TrOp> >' for 'std::basic_ostream<char, std::char_traits<char> >&
operator<<(std::basic_ostream<char, std::char_traits<char> >&, const
Expr<UnOp<Vector<double>, TrOp> >&)' does not match any template
declaration

So then, I decided to forward the function call to another function,
say print:

template <class A>
inline std:stream& print(std:stream& os, const Expr<A>& e) {
os<<e();
return os;
}

so this also works fine, and now I can specialize the function for
specific class of A:

template <>
inline std:stream& print<someClass>(std:stream& os, const
Expr<someClass>& e) {
// partially specialized for someClass
return os;
}

Now the questions is, is this the better way to do this? Forwarding a
function call seems right, but probably it can be done without another
function. I tried hard overloading operator<< but no success. Any
hints??

Thank you all...

a²

 

[Ian Collins]

Hi... after trying several things with some templated code I decided
to ask the experts a couple of things. I have the following class
template:

template<class A>
class Expr {
A a_;
public:
... // some public functions
...
friend inline std:stream& operator<<(std:stream& os, const
Expr<A>& e) {
os<<e.a_();

That line won't compile.

So then, I decided to forward the function call to another function,
say print:

template <class A>
inline std:stream& print(std:stream& os, const Expr<A>& e) {
os<<e();
return os;
}

so this also works fine, and now I can specialize the function for
specific class of A:

template <>
inline std:stream& print<someClass>(std:stream& os, const
Expr<someClass>& e) {
// partially specialized for someClass
return os;
}

Now the questions is, is this the better way to do this? Forwarding a
function call seems right, but probably it can be done without another
function. I tried hard overloading operator<< but no success. Any
hints??

You could make the outputting function a member of the class, say

std:stream& output( std:stream& os ) const
{
os << a_;
return os;
}

friend std:stream& operator<<(std:stream& os, const Expr& e)
{
return e.output( os );
}

and specialise output as required:

template <>
std:stream& Expr<int>:utput( std:stream& os ) const
{
return os << "Boo!";
}

 

[aaragon]

That line won't compile.










You could make the outputting function a member of the class, say

std:stream& output( std:stream& os ) const
{
os << a_;
return os;
}

friend std:stream& operator<<(std:stream& os, const Expr& e)
{
return e.output( os );
}

and specialise output as required:

template <>
std:stream& Expr<int>:utput( std:stream& os ) const
{
return os << "Boo!";

}

Thanks for the tip...

 

[James Kanze]

Hi... after trying several things with some templated code I
decided to ask the experts a couple of things. I have the
following class template:

template<class A>
class Expr {
A a_;
public:
... // some public functions
...
friend inline std:stream& operator<<(std:stream& os, const
Expr<A>& e) {
os<<e.a_();
return os;
}
};

operator<< works just fine,

But maybe not for the reason you think.

but then I wanted to have the operator<< with different
behaviors depending on the template parameter. So, I tried the
following inside the class:
// declaration inside the class
friend std:stream& operator<<<A>(std:stream& os, const Expr&
e);

and defining the function outside:
template <class A>
inline std:stream& operator<<(std:stream& os, const Expr<A>&
e) {
os<<e();
return os;
}

In sum, you declare a non-template function as friend, and you
implement a function template. They're not the same thing.

They way I usually handle this is more or less what Ian
suggested: I define a member function which does the actual
work, and then invoke it in my operator<<. But it's possible to
declare function templates, or specializations of function
templates, as friends. Note however that to do so, it is
necessary to declare the function template before the class
template definition.

Then I got just too many errors because of ambiguous calls and
others like:
cppblas.hpp:862: error: template-id 'operator<< <UnOp<Vector<double>,
TrOp> >' for 'std::basic_ostream<char, std::char_traits<char> >&
operator<<(std::basic_ostream<char, std::char_traits<char> >&, const
Expr<UnOp<Vector<double>, TrOp> >&)' does not match any template
declaration

So then, I decided to forward the function call to another
function, say print:

template <class A>
inline std:stream& print(std:stream& os, const Expr<A>& e) {
os<<e();
return os;
}

so this also works fine, and now I can specialize the function
for specific class of A:

template <>
inline std:stream& print<someClass>(std:stream& os, const
Expr<someClass>& e) {
// partially specialized for someClass
return os;
}

Now the questions is, is this the better way to do this?

That's the way I do it.

Forwarding a function call seems right, but probably it can be
done without another function. I tried hard overloading
operator<< but no success. Any hints??

I'm not sure of the exact syntax, because I don't use it, but
you'd probably have to start with something like:

template < typename T >
class Expr ;

template< typename T >
std:stream& operator<<( std:stream&, Expr< T > const& ) ;

template< typename T >
class Expr
{
// ...
friend template<> std:stream& operator<<(
std:stream&, Expr< T > const7 ) ;
// (or something like that. As I said, I'm not too
// sure of the syntax.)
} ;

 

[aaragon]

But maybe not for the reason you think.


In sum, you declare a non-template function as friend, and you
implement a function template. They're not the same thing.

They way I usually handle this is more or less what Ian
suggested: I define a member function which does the actual
work, and then invoke it in my operator<<. But it's possible to
declare function templates, or specializations of function
templates, as friends. Note however that to do so, it is
necessary to declare the function template before the class
template definition.




That's the way I do it.


I'm not sure of the exact syntax, because I don't use it, but
you'd probably have to start with something like:

template < typename T >
class Expr ;

template< typename T >
std:stream& operator<<( std:stream&, Expr< T > const& ) ;

template< typename T >
class Expr
{
// ...
friend template<> std:stream& operator<<(
std:stream&, Expr< T > const7 ) ;
// (or something like that. As I said, I'm not too
// sure of the syntax.)
} ;

--
James Kanze (GABI Software) email:[email protected]
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

Thanks James...