2. יכול להיות ששוב לא הבנתי למה אתה מתכוון:

קוד:

#include <iostream>

template<typename T>
class Num {
public:
	typedef T NumericT;

	Num(const NumericT& d) : m_n(d) {}
	~Num() {}

	operator double() { return m_n; }

private:
	NumericT m_n;
};

template<typename T>
class Num2 {
public:
	typedef T NumericT;

	Num2(const NumericT& d) : m_n(d) {}
	~Num2() {}

	operator double() { return m_n; }
	template<typename U>
	operator Num<U>() { std::cout << "CASTING" << std::endl; return Num<U>(m_n); }

private:
	NumericT m_n;
};

int main() {
	Num<float> i(1.23f);
	std::cout << i << std::endl;

	Num2<int> j(123);
	Num<long> jj = j;
	std::cout   << j  << std::endl
				<< jj << std::endl;

	Num2<double> k(12.34);
	Num<long> kk = k;
	std::cout   << k  << std::endl
				<< kk << std::endl;
	
	return 0;
} 

אל תשכח שאם אתה ממיר לאותו טיפוס טמפלייטי, אופרטור הקאסט לא צריך להיות טמפלייטי, ואז נחסכות הבעיות במקרים האחרים.

3. זה גם הטיעון בעד לא להשתמש ב-const: "מי שמספיק טיפש לשנות את המשתנה גם אם ההערה מעליו אומרת לא לשנות - מגיע לו"...