Ich habe zwei Funktionen f, g mit derselben Signatur. Ich will nun bewerkstelligen, dass ich mit templates die eine oder die andere aufrufen kann:

template <????>
void foo()
{
  // hier soll abhängig von ???? f oder g aufgerufen werden
}

Wie mache ich das?

struct call_f_tag {};
struct call_g_tag {};
template<> void foo<call_f_tag>() { f(); }
template<> void foo<call_g_tag>() { g(); }

// Aufruf:
foo<call_f_tag>();
foo<call_g_tag>();

(ungetestet)

Die iterator_tags funktionieren auf ähnliche Art und Weise.

class f
{
    void operator() (void)    
    {
    /*
     *
     */
    }
};

class g
{
    void operator() (void)
    {
    /*
     *
     */
    }
};

template<typename T>
void foo()
{
    T funk;
    funk();
}

// Aufruf:
foo<g>();
foo<f>();

void foo(bool call_f) {
  if(call_f) f();
  else g();
}

Das ganze geht auch als template

template <bool call_f>
void foo() {
  if(call_f) f();
  else g();
}

Ansonsten ist Spezialisierung (wie von templater gezeigt) ein üblicher Weg.

p.S.:
Die "tag" Variante von "templater" macht IMO Sinn, wenn man das Template "zumachen" will, also dem User die Möglichkeit nehmen jeden beliebigen Funktor/Funktionszeiger zu übergeben.