Re: Why is a template method instantiated and preferred over method with matching signature?

I'm having a little issue with the compiler trying to instantiate
template code for a type even if there is an explicit match for
that type.

Here's some example code that compiles and runs on g++ 4.4.1:

//// code start

#include <iostream>

class IBase
{

public:

  virtual ~IBase() {}

};

class Derived : public IBase {};

class FooCaller
{

public:

  void foo(int value)
  {
    std::cout << "foo(int)\n";
  }

  void foo(double value)
  {
    std::cout << "foo(double)\n";
  }

  // void foo(const IBase * p)
  void foo(IBase * p)
  {
    std::cout << "foo(IBase*)\n";
  }

  template<typename T>
  void foo(const T & t)
  {
    std::cout << "foo(T)\n";
  }

};

int main(int argc,char ** argv)
{
  int iVal = 0;
  double dVal = 0;
  Derived derived;

  FooCaller f;

  f.foo(iVal);
  f.foo(dVal);
  f.foo(derived);

  IBase * pValue = &derived;
  f.foo(pValue);

  return 0;
}

//// code end

Compiling and running this program produces the following output:

foo(int)
foo(double)
foo(T)
foo(IBase*)

This is actually what I'm looking for. However, I do not want to pass
the IBase pointer as a non-const. If I replace the plain pointer
declaration with the const pointer declaration, i.e.

FooCaller::foo(IBase*) -> FooCaller::foo(const IBase*)

then recompiling and running the program produces the following output:

foo(int)
foo(double)
foo(T)
foo(T)

Even though I have a method foo(const IBase*), the compiler instantiates
a method FooCaller::foo(const IBase* &) instead, which is not really
what I want (especially if I still want to do something useful within
the method on that data).
[..]

What am I doing wrong here?