Conversion constructors and template arguments.

[Kevin Ruland]

Hi all.

I have a template class with conversion operator:

template< typename T >
class FooWrapper {
public:
FooWrapper( const T& rhs );
}

Along with some specializations for this:

template<>
class FooWrapper<MyType> {
public:
FooWrapper( const MyType& rhs );
}

and so forth.

Now I'm defining some operators using templates which I want to be
limited to only FooWrapper<T> classes.

template<typename T, typename U>
int
operator+ (const FooWrapper<T>&, const FooWrapper<T>& );


The problem I'm having is compiling code like this:

MyType a, b;
int i = a + b;

Under g++ 3.2.3.20030502 it states there is no operator+ for MyType&,
MyType&.

Really, my question is why are the user defined conversions not
considered when trying to match with the customer operator+?

Thanks much.

Kevin Ruland

 

[Victor Bazarov]

[...]
Really, my question is why are the user defined conversions not considered
when trying to match with the customer operator+?

Just a thought: the "why" questions should really be asked in
comp.std.c++. That's where they discuss the rationale behind
certain decisions that control how C++ is standardized.

V

 

[Shezan Baig]

I have a template class with conversion operator:

template< typename T >
class FooWrapper {
public:
FooWrapper( const T& rhs );
}

Along with some specializations for this:

template<>
class FooWrapper<MyType> {
public:
FooWrapper( const MyType& rhs );
}
[snip]

template<typename T, typename U>
int
operator+ (const FooWrapper<T>&, const FooWrapper<T>& );
[snip]

MyType a, b;
int i = a + b;

Under g++ 3.2.3.20030502 it states there is no operator+ for MyType&,

MyType&.

Really, my question is why are the user defined conversions not
considered when trying to match with the customer operator+?

I'm not sure if this will work, but how about if you instantiate
operator+ for T = MyType:

template int operator+(const FooWrapper<MyType>&, const
FooWrapper<MyType>&);

Hope this helps,
-shez-

 

[Kevin Ruland]

I have a template class with conversion operator:

template< typename T >
class FooWrapper {
public:
FooWrapper( const T& rhs );
}

Along with some specializations for this:

template<>
class FooWrapper<MyType> {
public:
FooWrapper( const MyType& rhs );
}

[snip]

template<typename T, typename U>
int
operator+ (const FooWrapper<T>&, const FooWrapper<T>& );

[snip]

MyType a, b;
int i = a + b;

Under g++ 3.2.3.20030502 it states there is no operator+ for MyType&,

MyType&.

Really, my question is why are the user defined conversions not
considered when trying to match with the customer operator+?

I'm not sure if this will work, but how about if you instantiate
operator+ for T = MyType:

template int operator+(const FooWrapper<MyType>&, const
FooWrapper<MyType>&);

Actually this doesn't help. It still doesnt find the conversion operator.

I also tried adding an implicit conversion operator to MyClass, and that
didn't fix it.

If I were to do this, I might as well, not implement the operator as a
template to begin with and instead just implement all the combinations
that I'm going to need. The problem is I really have 4 different
instantiations of FooWrapper, so I end up with 16 different operator+.
And of course, I also have operator-, *, / etc....

Thanks for the advice though.