//---type select struct---//
template<bool flag,typename T,typename U>
struct Select
{
    typedef T SelectedType;
};

template<typename T,typename U>
struct Select<false,T,U>
{
    typedef U SelectedType;
};
template<typename U>
struct A_FundamentalTraits
{
    typedef null_type fund_type;
    enum{isFundamental=false};
};

template<>
struct A_FundamentalTraits<int>
{
    typedef int fund_type;
    enum{isFundamental=true};
};

template<typename T>
struct A_TypeTraits
{
private:

    template<typename U>
    struct A_RefTraits
    {
        enum{isRef=false};
        typedef null_type ref_type;
    };

    template<typename U>
    struct A_RefTraits<U&>
    {
        enum{isRef=true};
        typedef U& ref_type;
    };

    template<typename U>
    struct A_ConstRefTraits
    {
        enum{isCRef=false};
        typedef null_type cref_type;
    };

    template<typename U>
    struct A_ConstRefTraits<const U&>
    {
        enum{isCRef=true};
        typedef const U& cref_type;
    };


    template<typename U>
    struct ParameterTraits
    {
        typedef typename Select<A_FundamentalTraits<U>::isFundamental,U,const U&>::SelectedType ParameterType;
    };
    template<typename U>
    struct ParameterTraits<U&>
    {
        typedef U& ParameterType;
    };

public:
    typedef typename A_RefTraits<T>::ref_type ref_type;
    enum{isRef=A_RefTraits<T>::isRef};

    typedef typename A_ConstRefTraits<T>::cref_type cref_type;
    enum{isCRef=A_ConstRefTraits<T>::isCRef};

    typedef typename A_FundamentalTraits<T>::fund_type fund_type;
    enum{isFundamental=A_FundamentalTraits<T>::isFundamental};

     typedef typename ParameterTraits<T>::ParameterType ParameterType;
};

template<typename T>
void funcBy(T)
{
std::cout<<"parameter is ref: "<<((client::A_TypeTraits<T>::isRef)?"true":"false")<<std::endl;
std::cout<<"parameter is Cref: "<<((client::A_TypeTraits<T>::isCRef)?"true":"false")<<std::endl;
std::cout<<"parameter is by val: "<<((client::A_TypeTraits<T>::isFundamental)?"true":"false")<<std::endl<<std::endl;
}
A a;
A& ra = a;
    funcBy(client::A_TypeTraits<int>::ParameterType());
    funcBy(client::A_TypeTraits<A>::ParameterType(a));
    funcBy(client::A_TypeTraits<A&>::ParameterType(ra));

   std::cout<<"is ref: "<<((client::A_TypeTraits< client::A_TypeTraits<A&>::ParameterType >::isRef)?"true":"false")<<std::endl;

template<typename T>
void fooo(T i){T& ri=i;std::cout<<&i<<"fooo(T)\n";}

    std::cout<<(typeid(ii)==typeid(rii))<<std::endl;

    funcBy<A&>(client::A_TypeTraits<A&>::ParameterType(ra));

// функции над данными
int id(int x) { return x; }
int succ(int x) { return x+1; }
int pred(int x) { return x-1; }

void foo(int(*f)(int)) { std::cout << f(123) << std::endl; }

// функции над типами

template<class T> struct Id { typedef T type; };

template<class T> struct AddStar { typedef T* type; };

template<class T> struct RemoveStar { typedef T type; };
template<class T> struct RemoveStar<T*> { typedef T type; };

template< template<class> class Fun > void Foo()
{
  std::cout << typeid( typename Fun<int***>::type ).name() << std::endl;
}

int main()
{
  foo(id); foo(succ); foo(pred);
  Foo<Id>(); Foo<AddStar>(); Foo<RemoveStar>();
}

template<class TT> struct Foo
{
  typedef TT::ParameterType TheType;
  .....
};

К>template<class TT> struct Foo
К>{
К>  typedef TT::ParameterType TheType;
К>  .....
К>};
К>

int i;
A a;
foo(i);//Вызывается foo(int) **1
foo(a);//Вызывается foo(const A&) **2
ну или хотя бы так
foo(ParameterTraits<int>::ParameterType(i));// **1
foo(ParameterTraits<A>::ParameterType(a));// **2

но не 
foo<const A&>(a) или foo(ParameterTraits<const A&>::ParameterType(a));
//То есть мы не подсказываем компилятору foo<const A&>(a). Это выводится само через шаблон ParameterType<T> (T=A).

rpz>int i;
rpz>A a;
rpz>foo(i);//Вызывается foo(int) **1
rpz>foo(a);//Вызывается foo(const A&) **2

#include <iostream>
#include <typeinfo>

/////////////////////////
// инструменты для работы

#include <type_traits>
#include <boost/mpl/if.hpp>

// предикат, определяющий, какие типы мы будем передавать как есть (т.е. по значению):
// примитивные, указатели и ссылки (явно указанные ссылки будем передавать как ссылки)
template<class T> struct passed_by_value :
  std::integral_constant<bool, std::is_fundamental<T>::value | std::is_pointer<T>::value | std::is_reference<T>::value >
{};

// метафункция, возвращающая тип передаваемого аргумента по типу исходных данных
template<class T> struct argument_type : boost::mpl::if_< passed_by_value<T>, T, const T& > {};

//////////////////////////////////////////////////////////////
// бизнес-логика пусть будет здесь (чтобы ниже не повторяться)

template<class T> void foo_impl(T t) { std::cout << __PRETTY_FUNCTION__ << " : " << typeid(T).name() << std::endl; }
int x = 123;
std::string y = "hello";

void test_impl()
{
    foo_impl<int>(x);
    foo_impl<const std::string&>(y);
}

////////////////////////////////////////////////////////////
// лобовое решение - требует явно указывать параметр шаблона
template<class T> void foo0(typename argument_type<T>::type t) { foo_impl<typename argument_type<T>::type>(t); }

void test0()
{
  // ужасно!
  foo0<int>(x);
  foo0<std::string>(y);

  // для макроса сгодится (двойное упоминание аргумента)
  foo0<decltype(x)>(x);
  foo0<decltype(y)>(y);
}

///////////////////////////////////
// делаем чуть красивее - на SFINAE

template<class T> typename std::enable_if< passed_by_value<T>::value, void>::type foo1(T t)        { foo_impl<T>       (t); }
template<class T> typename std::enable_if<!passed_by_value<T>::value, void>::type foo1(const T& t) { foo_impl<const T&>(t); }
// плохо тем, что если нам нужна функция от двух и более аргументов, мы получим комбинаторный взрыв SFINAE

void test1()
{
  foo1(x);
  foo1(y);
}

////////////////////////////////////////////////////////////
// менее красиво, зато легче писать многоаргументные функции

// тип-обёртка для аргумента
template<class T> struct box_t
{
  typedef typename argument_type<T>::type type;
  type value;
  box_t(type v) : value(v) {}
};
// SFINAE здесь для того, чтобы последовательно провести политику партии :)
template<class T> typename std::enable_if< passed_by_value<T>::value, box_t<T> >::type box(T t)        { return box_t<T>(t); }
template<class T> typename std::enable_if<!passed_by_value<T>::value, box_t<T> >::type box(const T& t) { return box_t<T>(t); }

template<class T, class U> void foo2(box_t<T> t, box_t<U> u) // никакого SFINAE не потребовалось
{
  // не стал выдумывать, что б такого реализовать в этой функции - просто вызову нашу старую добрую дважды
  foo_impl<typename box_t<T>::type>(t.value); // вот, кстати: box_t выступил и объектом, и характеристикой типа
  foo_impl<typename box_t<U>::type>(u.value);
}

void test2()
{
  foo2(box(x), box(y));
}

// проверяем
int main()
{
  test_impl();
  test0();
  test1();
  test2();
}

template<bool, class> struct enable_if {};
template<class T> struct enable_if<true, T> { typedef T type; }; // только для true существует зависимое имя type

template<class T> box_t<T> box(T t)        { return box_t<T>(t); }
// либо
template<class T> box_t<T> box(const T& t) { return box_t<T>(t); }

... foo(box(z)) ...