about return type of an overloaded operator

[benben]

Given a class template Vector<>, I would like to overload operator +.
But I have a hard time deciding whether the return type should be
Vector<U> or Vector<V>, as in:
template <typename U, typename V>
Vector<U_or_V> operator+ (
const Vector<U>&,
const Vector<V>&);
Naturally, I would like U_or_V to be the type of (U() + V()), but,
pardon my limited knowledge, I have no idea how to achieve that.

Currently I am defaulting U_or_V just to U. But this has some subtle
implications. For example, the breach of the commutative law:

Vector<int> vi(0, 0, 0);
Vector<double> vd(1.1, 1.2, 1.3);

assert((vi + vd) == (vd + vi));

The above innocent code may not even compile depending on how operator==
is declared. If it did, it is again up to the details of operator== to
decide whether the assertion would succeed or fail. Ideally, both
addition expressions should give Vector<double> because (int() + double
()) is a double.

Any thought will be appreciated!

Ben

[benben]

Shark wrote:

Shark wrote:

How about you declare an abstract base class B from which U and V
derive, and in operator+ you can have a factory design pattern return
the appropriate type.

I forgot to add, that B should be a wrapper around your types. It makes
sense to me, if I understand the problem correctly.

Thank you shark!

The challenge is, I can't insert a base class for U and V because they
can be anything from built-in types (int, double, char, etc) to types
that must not exhibit virtuality (hence must not have an abstract base.)

It is possible though, as you have reminded me, to design a secondary
type to hold the operands temporarily and only evaluate the result
against a certain type upon assignment.

But this will render the orginal design far more complex and much less
maintainable.

Anyway your help was much appreciated!

Ben

[owl ling]

this is good idea.....but there are a problem, RTTI(as "typeof") is a
technique for run-time. but the template argument be sure in
complier-time...

[benben]

Thank you John for the time and effort in your reply! I much appreciated.

I did considered using a traits class. I can put my effort in and give
all the specializations necessary for built-in types. But as the vector
class also takes class types it is required of the USER of the vector
class to provide specializations of whatever custom type they use.
Whether the user remembers (or cares) to give a specialization would
have an implication on the semantic, which can be subtle. And this holds
me back from using a traits class to determine the return type.

Yours,
Ben

[Earl Purple]

an**@servocomm. freeserve.co.uk wrote:

template <typename U, typename V>
Vector< BOOST_TYPEOF_TP L(U() + V())> operator+ (
const Vector<U>&,
const Vector<V>&);

You may have to do some work to 'register' U and V though Boost.Typeof
can make use of compiler extensions in some cases too. 'registration'
is covered in the documentation. There are some differences between use
with templates and non_templates too, but its probably the nearest to
true language support.

Check it out.

regards
Andy Little

Much that I appreciate the contributions of boost, I just hope that all
these macros never make the standard.

The best I could come up with, that compiles and runs correctly is
this:

#include <algorithm>
#include <iostream>
#include <vector>

template < typename T >
class Vector
{
private:
typedef std::vector< T > vec_type;

std::vector< T > realVec;
public:
typedef typename vec_type::const _iterator const_iterator;
typedef typename vec_type::size_ type size_type;

void reserve( size_type sz )
{
realVec.reserve ( sz );
}

size_type size() const
{
return realVec.size();
}

const_iterator begin() const
{
return realVec.begin() ;
}

const_iterator end() const
{
return realVec.end();
}

void push_back( const T& t )
{
return realVec.push_ba ck( t );
}
};

template < typename U, typename V, typename W >
Vector<W> vecSum( const Vector<U> & uvec, const Vector<V> & vvec, W w )
{
Vector<W> wvec;
typename Vector<U>::cons t_iterator uIter = uvec.begin();
typename Vector<U>::cons t_iterator uEnd = uvec.end();
typename Vector<V>::cons t_iterator vIter = vvec.begin();

wvec.reserve( uvec.size() );
while ( uIter != uEnd )
{
wvec.push_back( *uIter + *vIter );
++uIter;
++vIter;
}
return wvec;
}

template < typename T >
void outputVec( const Vector<T> & t )
{
std::copy( t.begin(), t.end(), std::ostream_it erator< T >(
std::cout, "\n" ) );
}

template < typename U, typename V >
void outputVecSum( const Vector<U> & uvec, const Vector<V> & vvec )
{
outputVec( vecSum( uvec, vvec, U() + V() ) );
}

int main()
{
Vector< int > uvec;
Vector< double > vvec;

uvec.push_back( 1 );
uvec.push_back( 2 );
uvec.push_back( 3 );

vvec.push_back( 1.5 );
vvec.push_back( 2.5 );
vvec.push_back( 3.5 );

outputVecSum( uvec, vvec );
}

Note I made every effort never to work out what type W would be (thus
outputVec and outputVecSum as templates).

[Shark]

> template < typename U, typename V, typename W >

Vector<W> vecSum( const Vector<U> & uvec, const Vector<V> & vvec, W w )

Note I made every effort never to work out what type W would be (thus
outputVec and outputVecSum as templates).

this is cool, but to get a sum, we have to pass a 3rd argument, right?
So basically we cannot implement operator= without using a 3rd
parameter in these terms?

[Shark]

> template < typename U, typename V, typename W >

Vector<W> vecSum( const Vector<U> & uvec, const Vector<V> & vvec, W w )

Note I made every effort never to work out what type W would be (thus
outputVec and outputVecSum as templates).

this is cool, but to get a sum, we have to pass a 3rd argument, right?
So basically we cannot implement operator= without using a 3rd
parameter in these terms?

[andy]

Earl Purple wrote:

an**@servocomm. freeserve.co.uk wrote:

template <typename U, typename V>
Vector< BOOST_TYPEOF_TP L(U() + V())> operator+ (
const Vector<U>&,
const Vector<V>&);

You may have to do some work to 'register' U and V though Boost.Typeof
can make use of compiler extensions in some cases too. 'registration'
is covered in the documentation. There are some differences between use
with templates and non_templates too, but its probably the nearest to
true language support.

Check it out.

regards
Andy Little

Much that I appreciate the contributions of boost, I just hope that all
these macros never make the standard.

Boost.Typeof cant be anything but a macro for now. AFAIK The author is
fully aware that its only standing in for proper language support. IOW
its a macro exactly because the facilities it provides are not in the
standard. Notwithstanding that its a masterpiece IMO. Unfortunately it
is only available from boost cvs at the monent. I'm not sure if it
will make the next boost distro or not, but I hope it does.

regards
Andy Little

[michael.fawcett]

I didn't check CVS, but the file I'm currently using has this in the
comments so it sounds like what Andy is talking about.

"Return Type Deduction
[JDG Sept. 15, 2003]

Before C++ adopts the typeof, there is currently no way to deduce the
result type of an expression such as x + y. This deficiency is a major
problem with template metaprogramming ; for example, when writing
forwarding functions that attempt to capture the essence of an
expression inside a function."

I use it for the exact same purpose as the OP like so:

template <typename T0, typename T1>
typename boost::result_o f_plus<vec3<T0> , vec3<T1> >::type
operator+(vec3< T0> lhs, const vec3<T1> &rhs);

which is slightly different than your usage, but only because I
specialized the result_of struct on my type. I too hope this makes it
into the next boost distro.