How to specialize classes for all reference types C++03

Question

Please notice C++03 is what I really need, but for knowledge sake, I would like to see some more pretty implementations in C++11 as well.

I need a template class

template <typename T>
class A {
private:
    T m_member;

public:
    A(T _member);    
    //... MORE STUFF
    void foo(T param);
};

I need:

1) If A is compiled with a value type (including pointers, which by themselves are passed by value):

Then I need A to look like this (exactly like above)

class A {
private:
    T m_member;

public:
    A(T _member);    
    //... MORE STUFF
    void foo(T param);
};

2) If A is compiled with a reference type (for example int&):

Then I need A to look like this:

class A{
private:
    T& m_member;

public:
    A(T& _member);    
    //... MORE STUFF
    void foo(T param); // still the same T, not T&
};

If I knew A received only ints, then i would be able to use specialization. But any type can be used by A's user:

main.cpp

A<int> a1;//1st version
A<int&> a2;//2nd version
A<B> a3;//1st version
A<B&> a4;//2nd version
A<C*> a5;//1st version

Answer 1

As seen (correctly) in this thread Specializing function template for reference types, the remove_reference suggested here won't work. It just won't go into the second implementation EVER, because the compiler sees T& and T just the same.

Instead you could MANUALLY tell the compiler that it is now dealing with a reference type, using the same specialization trick

template<typename T, bool isReference>
class A {
};

template<typename T>
class A<T,false>{
private:
    T m_member;

public:
    A(T _member);    
    //... MORE STUFF
    void foo(T param);
}
/////////////////////////
template<typename T>
class A<T,true>{
private:
    T& m_member;

public:
    A(T& _member);    
    //... MORE STUFF
    void foo(T param);
}

If you want to extract some similar behavior and avoid the code dupelication this solution causes, you could easily extract that behavior to a Base Class<T>, and do

template<typename T,bool isReference>
class A : public BaseClass<T>{
}

and so on.

Usage would be

main.cpp

A<int,false> a1;//1st version
A<int&,true> a2;//2nd version
A<B,false> a3;//1st version
A<B&,true> a4;//2nd version
A<C*,false> a5;//1st version, as pointers are value types