Teilweise Spezialisierung von Member-Funktionsimplementierungen

Question

Ich refaktoriere derzeit einige Code, der explizit eine Member-Funktion einer Klassenvorlage mit zwei Vorlagenelementen spezialisiert.

template 
class Foo
{
  void bar();
};

template 
void Foo::bar()
{ /* Generischer Code */ }

template <>
void Foo::bar()
{ /* Einige spezielle Funktion */ }

Jetzt habe ich einige weitere Vorlagenelemente hinzugefügt, sodass die Klasse jetzt so aussieht:

template 
class Foo
{
  void bar();
};

Diese beiden zusätzlichen Elemente fügen nur Typdefinitionen zu meiner Klasse hinzu, sodass sich die Laufzeitfunktionalität nicht wirklich ändert. Gibt es eine Möglichkeit, die (jetzt teilweise) spezialisierte Implementierung von bar beizubehalten? Ich scheine die Syntax dafür nicht herausfinden zu können und habe den Verdacht, dass es möglicherweise nicht möglich ist.

Bearbeiten: Ich suche etwas wie:

template 
void foo::bar()
{
   /* spezialisierte Implementierung */
}

was anscheinend nicht kompiliert...

Answer 1

Sie haben recht, es ist nicht möglich.

Was Sie tun können, ist eine Hilfsklassenvorlage innerhalb des neuen Foo zu erstellen und die spezialisierte Funktion als nicht-template Mitgliedsfunktion darin zu platzieren. Spezialisieren Sie die Hilfsklasse anstelle der Funktion.

Eine weitere Alternative besteht darin, die Spezialisierung in eine Nicht-Template-Überladung umzuwandeln.

Answer 2

Ich glaube nicht, dass das, was du willst, so einfach möglich ist. Wie wäre es mit etwas so etwas?

template 
class FooBase
{
    void bar();
};

template 
void FooBase::bar()
{ /* Generischer Code */ }

template 
class Foo
    : public FooBase 
{ };

template 
class Foo
    : public FooBase 
{
    void bar ();
};

template 
void Foo::bar()
{ /* Eine spezielle Funktion */ }

Answer 3

Sie können eine Basisklasse erstellen, in der Sie alle Ihre Elemente definieren können, außer bar(), und dann abgeleitete Klassen erstellen (eine für allgemeine Zwecke, eine für SomeType):

template 
class FooBase
{
       // Alle anderen Elemente 
};

template 
class Foo: public FooBase
{
public:
      void bar()
      {

      }
};

struct SomeType {};

template 
class Foo: public FooBase
{
public:
    void bar()
    {

    }
};

int main()
{
    Foo b;
    b.bar();
}

Answer 4

Sie können dies erreichen, indem Sie einen spezialisierten Funktor anstelle einer Funktion verwenden:

#include 

typedef int SomeType;

template 
class BarFunctor {
public:
    void operator()() {
        std::cout << "allgemein" << std::endl;
    }
};

template <>
class BarFunctor {
public:
    void operator()() {
        std::cout << "speziell" << std::endl;
    }
};

template 
class Foo {
public:
    void helloWorld() {
        std::cout << "Hallo Welt!" << std::endl;
    }

    void bar() {
        return _bar();
    }

private:
    BarFunctor _bar;
};

int main() {

    Foo gen;
    Foo spe;
    gen.helloWorld();
    spe.helloWorld();
    gen.bar();
    spe.bar();
    return 0;
}