Template problems in Visual C++ 6

[Starx]

With the following class:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);
friend testClass operator +(testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

When I use the overloaded addition operator on two testClass objects (a
+ b) things work fine. But when I try to add a testClass object with
another type, for example:

testClass<int> a, b = 2;
a = b + 2;

I get these two errors:

error C2784: 'class testClass<numericType> __cdecl operator +(class
testClass<numericType>,class testClass<numericType>)' : could not
deduce template argument for 'class testClass<numericType>' from 'class
testClass<int>'

error C2676: binary '+' : 'class testClass<int>' does not define this
operator or a conversion to a type acceptable to the predefined
operator

Can anyone tell me what's causing these errors and how I could get rid
of them?

[Steven T. Hatton]

Starx wrote:

With the following class:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);
friend testClass operator +(testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

When I use the overloaded addition operator on two testClass objects (a
+ b) things work fine. But when I try to add a testClass object with
another type, for example:

testClass<int> a, b = 2;
a = b + 2;

I get these two errors:

Try adding a conversion operator to the type you are working with. Templates
are pretty stubborn about type conversion.

--
If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true.-Bertrand Russell

[Starx]

But because the type is templated I can't add a conversion operator. I
don't know what type I'll be working with.

Wouldn't the testClass(numericType) constructor handle it anyway?

[Steven T. Hatton]

Starx wrote:

But because the type is templated I can't add a conversion operator. I
don't know what type I'll be working with.

Wouldn't the testClass(numericType) constructor handle it anyway?

Have you tried creating a member fuction template operator+=(), and then
using that to create the namespace local binary operator+()?
--
If our hypothesis is about anything and not about some one or more
particular things, then our deductions constitute mathematics. Thus
mathematics may be defined as the subject in which we never know what we
are talking about, nor whether what we are saying is true.-Bertrand Russell

[Kai-Uwe Bux]

Starx wrote:

With the following class:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);
friend testClass operator +(testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

When I use the overloaded addition operator on two testClass objects (a
+ b) things work fine. But when I try to add a testClass object with
another type, for example:

testClass<int> a, b = 2;
a = b + 2;

I get these two errors:

error C2784: 'class testClass<numericType> __cdecl operator +(class
testClass<numericType>,class testClass<numericType>)' : could not
deduce template argument for 'class testClass<numericType>' from 'class
testClass<int>'

error C2676: binary '+' : 'class testClass<int>' does not define this
operator or a conversion to a type acceptable to the predefined
operator

Can anyone tell me what's causing these errors and how I could get rid
of them?

To me, templates and friends are non-intuitive. Try declaring things
beforehand:

template < class T >
class testClass;

template < class T >
testClass<T> operator+ ( testClass<T>, testClass<T> );
Now define:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);

// Note the <>:
friend testClass operator+<> (testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

Best

Kai-Uwe Bux

[Bill Shortall]

"Starx" <js****@gmail.com> wrote in message
news:11**********************@g49g2000cwa.googlegr oups.com...

With the following class:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);
friend testClass operator +(testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

When I use the overloaded addition operator on two testClass objects (a
+ b) things work fine. But when I try to add a testClass object with
another type, for example:

testClass<int> a, b = 2;
a = b + 2;

I get these two errors:

error C2784: 'class testClass<numericType> __cdecl operator +(class
testClass<numericType>,class testClass<numericType>)' : could not
deduce template argument for 'class testClass<numericType>' from 'class
testClass<int>'

error C2676: binary '+' : 'class testClass<int>' does not define this
operator or a conversion to a type acceptable to the predefined
operator

Can anyone tell me what's causing these errors and how I could get rid
of them?

I think you will need to define an operator for addition by a constant e.g
something like

template <class numericType> testClass<numericType> operator +(testClass<numericType> a, const numericType c) {
testClass<numericType> returnVal;
returnVal.x = a.x + c;
return returnVal;
}

Bill Shortall

[John Shell]

Starx wrote:

With the following class:

template <class numericType>
class testClass
{
public:
testClass(numericType val = 0);
friend testClass operator +(testClass a, testClass b);
private:
numericType x;
};

template <class numericType>
testClass<numericType>::testClass(numericType val)
: x(val)
{
}

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
testClass<numericType> b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b.x;
return returnVal;
}

When I use the overloaded addition operator on two testClass objects (a
+ b) things work fine. But when I try to add a testClass object with
another type, for example:

testClass<int> a, b = 2;
a = b + 2;

I get these two errors:

error C2784: 'class testClass<numericType> __cdecl operator +(class
testClass<numericType>,class testClass<numericType>)' : could not
deduce template argument for 'class testClass<numericType>' from 'class
testClass<int>'

error C2676: binary '+' : 'class testClass<int>' does not define this
operator or a conversion to a type acceptable to the predefined
operator

Can anyone tell me what's causing these errors and how I could get rid
of them?

Add this function:

template <class numericType>
testClass<numericType> operator +(testClass<numericType> a,
numericType b)
{
testClass<numericType> returnVal;
returnVal.x = a.x + b;
return returnVal;
}

Or provide an explicit conversion, like this:
a = b + testClass<int>(2);