code:

	template <class T, class U>
	struct max_type
	{
		enum type_type {GENERAL, INTEGRAL, BIG_INTEGRAL, FLOATING_POINT};
		static const type_type t_type = (boost::is_integral<T>::value)?
                  INTEGRAL : (boost::is_same<T, int64_t>::value || boost::is_same<T, uint64_t>::value)?
			BIG_INTEGRAL : (boost::is_floating_point<T>::value)?
			FLOATING_POINT : GENERAL;
		static const type_type u_type = (boost::is_integral<U>::value)?
                  INTEGRAL : (boost::is_same<U, int64_t>::value || boost::is_same<U, uint64_t>::value)?
			BIG_INTEGRAL : (boost::is_floating_point<U>::value)?
			FLOATING_POINT : GENERAL;

		template <type_type selector1, type_type selector2>
		struct Result
		{
			typedef T type;
		};

		template<type_type selector2>
		struct Result<FLOATING_POINT, selector2>
		{
			typedef double type;
		};

		template<type_type selector2>
		struct Result<selector2, FLOATING_POINT>
		{
			typedef double type;
		};

		template<>
		struct Result<INTEGRAL, BIG_INTEGRAL>
		{
			typedef U type;
		};

		typedef typename Result<t_type, u_type>::type type;
	};

template <class T1, unsigned char Dim1, class T2 unsigned char Dim2>
typename max_Type<T1, T2>::type scalarMult(const Vector<T1, Dim1>& v1, copnst Vector<T2, Dim2>& v2)
{
   ...
}

code:

#include <boost/mpl/if.hpp>
#include <boost/type_traits/is_same.hpp>
#include <boost/type_traits/is_integral.hpp>
#include <boost/type_traits/is_floating_point.hpp>
#include <typeinfo>

#include <iostream>

using std::cout;

template <typename T, unsigned char Dim> class Vector {

};

template <class T, class U>	struct max_type	{		
	enum type_name {GENERAL, INTEGRAL, BIG_INTEGRAL, FLOATING_POINT};		
	static const type_name t_type = (boost::is_integral<T>::value) ? INTEGRAL : 
		(boost::is_same<T, __int64>::value)? BIG_INTEGRAL : 
			(boost::is_floating_point<T>::value)? FLOATING_POINT : 
				GENERAL;

	static const type_name u_type = (boost::is_integral<U>::value) ? INTEGRAL : 
		(boost::is_same<U, __int64>::value) ? BIG_INTEGRAL : 
			(boost::is_floating_point<U>::value)? FLOATING_POINT : 
				GENERAL;		
	static const bool	_max = t_type > u_type;
public:
	typedef typename boost::mpl::if_c< _max, typename T, typename U>::type  type;	
};

template <typename T1, unsigned char Dim1, typename T2, unsigned char Dim2>
typename max_type<T1, T2>::type 
	scalarMult(const Vector<T1, Dim1>& v1, const Vector<T2, Dim2>& v2)
{
	max_type<T1, T2>::type	_result(0);
	cout << typeid(_result).name() << std::endl;
	return	_result;
}

int main()
{
	Vector<int, 20> a;
	Vector<unsigned, 30> b;
	scalarMult(a, b);
	return 0;
}
 

 
• multi_array
   
• multi_index
   
• array
   
• range
   
• operators
   
• tuple
   
• variant
  

В ответ на:

---

typedef typename boost::if_c< _max, typename T, typename U>::type type;

---