How could we measured the relationship between types and binary files generated by
compilers?

Code:
template<typename T>
T Max(T const A, T const B)
{
  return A > B ? A : B;
}

void testMax()
{
  int a = 5, b = 10;
  double c = 44.4, d = 33.23;
  Max(a, b);
  Max(c, d);
}
is same as
Code:
int Max(int const A, int const B)
{
  return A > B ? A : B;
}

double Max(double const A, double const B)
{
  return A > B ? A : B;
}
Ok, I know I could ask the compiler to generate the "Max" I need
and it is same as handcrafted codes
but what about this
Code:
typedef boost::mpl::vector<int, double, char, size_t, long double>  complex_types;
would the complex_types consume more binary codes to save the types than
primitive types?

Besides, when we do something like TMP like this
Code:
class NullType;

template<typename T, typename U>
class Typelist
{
  typedef T Head;
  typedef U Tail;
};

template<typename TList>
class length;

template<>
class length<NullType>
{
  public :
    enum{ Value = 0 };
};

template<typename Head, typename Tail>
class length<Typelist<Head, Tail> >
{
  public :
    enum { Value = 1 + length<Tail>::Value };
};
what we really get is an enumerator constant "Value"
would those recursive steps generate binary codes too?
Or compiler would optimize it?
Thanks