Thread: Templates question

Say you have a templated class:

Code:

template <typname T>
class myClass
{
...
};

And you want to declare two myClass objects something like this:

Code:

int main(void)
{
myClass<int> intMyObj;
myClass<short> shortMyObj;


}

And you want to be able to assign and compare the two objects...
i.e.:

Code:

intMyObj+=shortMyObj;

obviously involves operator overloading, but how do you make the two types compatible?

You can overload type conversions:

Code:

class Ojbect
{
public:
    
    operator Type();  //Conversion from Object to Type
    
    ...
    ...
};

Then you can say:

Type a;
Object b;

a = b;

Note there is no return value specified in the operator function because the target type is implicit, so the function must return an object of type Type.

Hm that doesn't seem to work, are you sure thats right for templated classes?

I'm getting "no match for..." errors when i try to use my overloaded assignment operator

Ok thanks I'll try that but another question. What if I want to static_cast<myClass>. What needs to be done before this is possible (or is it even possible)? For example:

Code:

char c='c';
myClass<int> x=static_cast<myClass>c;

Edit: Hm your example isnt working:

Code:

template <typename T,typename U>
myClass<T> myClass<T>::operator= ( myClass<U> & two)
{
if (this==&two)
  return (itsVal);
  
return (itsVal=two.getitsVal()) ; 
}

Errors (dont make sense...):

64 C:\Dev-Cpp\dd.cpp
prototype for `Integer<T>
candidate is C:\Dev-Cpp\dd.cpp:13
Integer<T>
64 C:\Dev-Cpp\dd.cpp
template definition of non-template `Integer<T>

"I don't think so. Maybe you made a mistake somewhere?"

Here's an example:

Code:

#include<iostream>
#include<iomanip>

using namespace std;

class Test
{
public:
	double a;

	operator char*()
	{
		return "Hello world.";
	}
};


int main()
{	

	Test my_test;
	my_test.a = 10.0;

	cout<<setprecision(2)<<fixed;
	cout<<my_test.a<<endl;

	
	char* pch;
	pch = my_test;
	cout<<pch<<endl;
	

	return 0;

}

You can also use constructors to implement conversions:

Type2(const Type1& a); //coverts from Type1 to Type2

Both 7stud's and ygf's codes will work, but personally, I'd avoid both of them. Essentially what you are doing is adding type-specialized code to something which is generalized (namely, a templated class such as this).

7stud's would cause a proliferation of code (which is what templates are partially designed to avoid), and ygf's could be the cause of some very subtle errors (truncation errors from the cast operation ... which probably should have a 'static_cast' to make it clear).

Anyways, what I'd advise is a more generic solution like the following :

Code:

#include <functional>

template<typename T>
class test {
public:
  T get_value() const { return value; }

  template<typename A, typename Func>
  void assign(test<A>, Func);
private:
  T value;
};

template<typename T> template<typename A, typename Func>
void test<T>::assign(test<A> src, Func convert) {
  value = convert(value, src.get_value());
}

struct convert_char : public std::binary_function<int, char, int> {
  int operator()(int x, char y) { return x + static_cast<int>(y); }
};

int main() {
  test<int> obj_a;
  test<char> obj_b;

  obj_a.assign(obj_b, convert_char());
}

The convert type in this case is a binary functor which takes the value of the object being assigned to first, and then the next parameter is the value of the second object. It is still possible to get around some of the conversion rules (i.e. poor casting practices with primitive types), but in this case, that is hard to do accidently. Also, this preserves the generic nature of the class (you aren't adding type-specialized code to it).