template<class T> bool cmp(T a, T b) {
    cout << "General template function called" << endl;
        return  (a<b);

}

template<class T> bool cmp(const T* a, const T* b) {
    cout << "Pointer template function called" << endl;
        return (*a<*b);
}

int j=5, i=7;
cmp(g, j);
cmp(&g, &j);

template < class T > 
bool cmp <T*>( const T* a, const T* b ) 
{
    cout << "Pointer template function called" << endl;
        return (*a<*b);
}

cmp<int *>(&g, &i);

#include <iostream>

using namespace std;

template<class T>
bool cmp(T a, T b)
{
  cout << "General template function called" << endl;
  return  (a<b);
}

template<>
bool cmp<int*>(int* a, int* b)
{
  cout << "Pointer template function called" << endl;
  return (*a<*b);
}

void main()
{
int j=5, i=7;
cmp(i, j);
cmp(&i, &j);
}

    int j=5, g=7;
    cmp(g, j);
    cmp((const int*)&g, (const int*)&j);

EX>>Если вообще для Pointers, то достаточно из оригинального примера убрать const

#include <iostream>

using namespace std;

template<class T>
bool cmp(const T& a, const T& b)
{
  cout << "General template function called" << endl;
  return  (a<b);
}

template<class T>
bool cmp(T* a, T* b)
{
  cout << "Pointer template function called" << endl;
  return (*a<*b);
}

void main()
{
int j=5, i=7;
cmp(i, j);
cmp(&i, &j);

const int a=1,b=2;
cmp(a,b);
cmp(&a,&b);

}

EX>Но! Для const указателей и просто указателей сгенерятся две разные функции

template<class T> bool cmp( T a,  T b)

а не как у тебя 

template<class T> bool cmp(const T& a, const T& b)

B>

template<class T> bool cmp( T a, T b)
template<class T> bool cmp < T* > ( T* a, T* b)

UGN>>template<class T> bool cmp( T a,  T b)

UGN>>а не как у тебя 

UGN>>template<class T> bool cmp(const T& a, const T& b)

UGN>>

EX>Ну... на здоровье

#include <boost/ref.hpp>

template<class T> bool cmp( T a,  T b);

struct some {};

void f()
{
    some a, b;
    cmp(boost::ref(a), boost::ref(b)); // накормим шаблон ссылками
}

template<class T>
bool cmp(const T& a, const T& b)
{
  cout << "General template function called" << endl;
  return  (a<b);
}

template<class T>
bool cmp(T* a, T* b )
{
  cout << "Pointer template function called" << endl;
  return (*a<*b);
}

int g=5, i=7;

cmp(g, i);
cmp(&g, &i);

Explicitly specifying the comparison criteria for each call is tedious. Fortunately, it is easy to pick
a default so that only uncommon comparison criteria have to be explicitly specified. This can be
implemented through overloading:

template< class T, class C >
int compare( const String<T>& str1, const String<T>& str2 ); // compare using C

template< class T >
int compare( const String<T>& str1, const String<T>& str2 ); // compare using Cmp<T>

template<class T> bool cmp(T a, T b) 
template<class T> bool cmp(const T* a, const T* b)

U> template< class T, class C >
U> int compare( const String<T>& str1, const String<T>& str2 ); // compare using C

U> template< class T >
U> int compare( const String<T>& str1, const String<T>& str2 ); // compare using Cmp<T>
U>

template< class T >
int compare( const String<T>& str1, const String<T>& str2 ) // compare using Cmp<T>
{
  return compare<Cmp<T>, T>(str1, str2);
}

UGN>template<class T> bool cmp(T a, T b) 
UGN>template<class T> bool cmp(const T* a, const T* b) 
UGN>

bool <int*> cmp(int*, int*)//1
bool <int> cmp(const int*, const int*)//2

bool cmp(int* p1, int*p2)//1
{
//...
}

bool cmp(const int* p1, const int*p2)//2
{
//...
}

//...
int n;
cmp(&n, &n);