Pointer to an overloaded method, error: "unresolved overloaded function type"

Error: unresolved overloaded function type

  g++ source.cpp
04_overloaded_unresolv.cpp: In member function `void wrapper_c::method1
()':
04_overloaded_unresolv.cpp:75: error: no matching function for call to
`wrapper_c::executeDirectly(<unresolved overloaded function type>,
std::string&, std::string&)'

This happens, if the method is overloaded.
Do you know how this could be solved? (How to make it work with
overloaded methods.)
g++ -v 3.4.5

#include <iostream>
#include <string>
#include <vector>
using std::vector;
using std::string;
using std::cout;
using std::endl;

// Pointers to methods.
// www.codeproject.com/cpp/FastDelegate.asp

class target_c
{
public:

   string* targetMethod(string& p1, string& p2)
   { return new string("stringString");
   }
// If this is taken in use, then the error message pops up in
compilation "unresolved overloaded function type"
   //string* targetMethod(const string& p1, const int& p2)
   //{ return new string("stringInt"); }
};

template <class CHILD>
class common_c
{
public:

   template <class RETURN_CLASS, class T1, class P1, class P2>
   RETURN_CLASS executeDirectly(RETURN_CLASS (T1::*my_memfunc_ptr)(P1&,
P2&),
                        P1& param1,
                        P2& param2)
   {
     try
     {
       return new string("test");
       //return
       //(
       // ((static_cast<CHILD*>(this))->getPointer())
       // ->*my_memfunc_ptr
       // )
       // (param1, param2);
       //return (static_cast<CHILD*>(this)->*my_memfunc_ptr)(param1,
param2);
     }
     catch (int& e)
     {
       string ex;
       ex = e;
       throw ex;
     }
   }

};

class wrapper_c : public common_c<wrapper_c> {
public:

   target_c* target_;

   target_c* getTarget() {return target_;}

   wrapper_c ()
   { target_ = new target_c();}

   void method1 ()
   {
     string arg1("");
     string arg2("");
     string* returnVal;

     // This line gives the error message during compilation:
     returnVal = executeDirectly<string*>(&target_c::targetMethod, arg1,
arg2);

     std::cout << *returnVal << std::endl;
   }

private:

};

int main()
{
   cout << "in MAIN, start" << endl;

   // This works ok:
   string* (target_c::*my_memfunc_ptr)(string&, string&);
   my_memfunc_ptr = &target_c::targetMethod;
   string a1("a1"), a2("a2");
   string* ret;
   target_c target;
   ret = (target.*my_memfunc_ptr)(a1,a2);
   cout << "called" << endl;
   cout << *ret << endl;

   // But this do not work::
   wrapper_c wrapper;
   wrapper.method1();

}

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]