typedef int Foo(const char*) const;

#include <string>
#include <iostream>

typedef std::string Foo(const char*);
typedef std::string Goo(const char*) const;

//Свободные функции
Foo f1;
Foo f2;
Foo f3;

std::string f1(const char* str) { return "f1 -- " + std::string(str); }
std::string f2(const char* str) { return "f2 -- " + std::string(str); }
std::string f3(const char* str) { return "f3 -- " + std::string(str); }

//Функции-члены
struct A
{
  Foo f1;
  Foo f2;
  Foo f3;
  
  Goo g1;
  Goo g2;
  Goo g3;
};

std::string A::f1(const char* str) { return "A::f1 -- " + std::string(str); }
std::string A::f2(const char* str) { return "A::f2 -- " + std::string(str); }
std::string A::f3(const char* str) { return "A::f3 -- " + std::string(str); }

std::string A::g1(const char* str) const { return "A::g1 -- " + std::string(str); }
std::string A::g2(const char* str) const { return "A::g2 -- " + std::string(str); }
std::string A::g3(const char* str) const { return "A::g3 -- " + std::string(str); }

//Использование
int main()
{
  A a;

  std::cout << f1("abc") << std::endl;
  std::cout << f2("def") << std::endl;
  std::cout << f3("ghi") << std::endl;

  std::cout << a.f1("jkl") << std::endl;
  std::cout << a.f2("mno") << std::endl;
  std::cout << a.f3("pqr") << std::endl;

  std::cout << a.g1("stu") << std::endl;
  std::cout << a.g2("vwx") << std::endl;
  std::cout << a.g3("yza") << std::endl;
}

[Note: a member function can be declared (but not defined) using a typedef for a function type. The resulting member function has exactly the same type as it would have if the function declarator were provided explicitly, see 8.3.5. For example,

typedef void fv(void);
typedef void fvc(void) const;
struct S {
fv memfunc1; // equivalent to: void memfunc1(void);
void memfunc2();
fvc memfunc3; // equivalent to: void memfunc3(void) const;
};
fv S::* pmfv1 = &S::memfunc1;
fv S::* pmfv2 = &S::memfunc2;
fvc S::* pmfv3 = &S::memfunc3;

Also see 14.3. ]

R>typedef int Foo(const char*) const;
R>

struct A
{
  std::string foo(int, double, const char*) const;
};
struct B
{
  std::string foo(int, double, const char*) const;
};

typedef std::string (A::*A_Foo)(int, double, const char*) const;
typedef std::string (B::*B_Foo)(int, double, const char*) const;

A_Foo a_foo = &A::foo;
B_Foo b_foo = &B::foo;

typedef std::string Foo(int, double, const char*) const;

struct A { Foo foo; };
struct B { Foo foo; };

Foo A::*a_foo = &A::foo;
Foo B::*b_foo = &B::foo;

R>typedef int Foo(const char*) const;
R>

e.cpp:189: error: invalid type qualifier for non-member function type
e.cpp:189: error: `const' and `volatile' function specifiers on `Foo' invalid in type declaration

#define DECLARE(sig, name) sig(,name)
#define DEFINE(sig, class, name) sig(class::,name)

// signatures
#define SIG1(class, name) void class name(int i, double d)
#define SIG2(class, name) void class name(double d, int i) const

// better name for SIG1
#define DECLARE_CALLBACK(name) DECLARE(SIG1, name)
#define DEFINE_CALLBACK(class, name) DEFINE(SIG1, class, name)

struct A
{
  DECLARE(SIG1, f1);
  DECLARE(SIG2, g);
  
  DECLARE_CALLBACK(f2);
};

DEFINE(SIG1, A, f1)
{
}

DEFINE(SIG2, A, g)
{
}

DEFINE_CALLBACK(A, f2)
{
}

struct A
{
  void f1(int i, double d);
  void g(double d, int i) const;

  void f2(int i, double d);
};

void A:: f1(int i, double d)
{
}

void A:: g(double d, int i) const
{
}

void A:: f2(int i, double d)
{
}

typedef void X();
typedef void Y() const;
typedef void Z(int);

struct A
{
  X foo;
  Y foo;
  Z foo;
};

struct A
{
  virtual Foo foo = 0;
};

class A
{
public:
  virtual int foo(int) const;
};

class B : public A
{
public:
  virtual int foo(int); //Забыли модификатор const и получили новую функцию вместо перекрытия существующей
};

typedef int Foo(int) const;
class A
{
public:
  virtual Foo foo;
};

class B : public A
{
public:
  virtual Foo foo; //virtual можно даже не писать в этом месте, его обычно пишут для большей наглядности
};

R>struct A
R>{
R>  virtual Foo foo = 0;
R>};
R>

struct A
{
  virtual Foo h = 0;
  Foo f1;
  Foo f2;

struct A
{
  virtual std::string Moo(const char*) = 0;
  Foo f1;
  Foo f2;

struct A
{
  virtual Foo h = 0;
  Foo f1;
  Foo f2;
  Foo f3;
  
  Goo g1;
  Goo g2;
  Goo g3;
};

std::string A::h(const char* p)
{
    return p; // sorry! :-)
}

typedef void G (int);

struct X
{
    G f1 = 0;
};

int main()
{
    X y;
}

typedef void G (int);

union X
{
    G f1 = 666;
};

int main()
{
    X y;
}