Wie können wir eine generische Funktion in C schreiben, die Vorlagenfunktionen als Argumente akzeptiert?

Vorlagenfunktion als Vorlagenargument: Generische Funktionen mit Vorlagenparametern definieren

Die Herausforderung, generische Funktionen in C zu definieren, kann auftreten, wenn die internen Funktionen selbst generisch sind . In diesem Artikel wird eine Lösung mithilfe von Vorlagenparametern untersucht, um diese Hürde zu überwinden.

Betrachten Sie den folgenden Codeausschnitt, der das Problem veranschaulicht:

<code class="cpp">template<typename T>
void a(T t) {
   // do something
}

template<typename T>
void b(T t) {
   // something else
}

template< ...param... > // ???
void function() {
    param<SomeType>(someobj);
    param<AnotherType>(someotherobj);
}

void test() {
    function<a>();
    function<b>();
}</code>

Die Schwierigkeit besteht darin, zu bestimmen, wie die Funktionsvorlage korrekt definiert wird . Um dieses Problem zu lösen, verwenden wir eine Technik, die als „Template-Template-Parameter“ bekannt ist.

Template-Template-Parameter

Template-Template-Parameter ermöglichen es uns, Template-Funktionen als Argumente an andere Templates zu übergeben. Dies bietet die Flexibilität, generische Funktionen zu erstellen, die auf einem bestimmten Satz von Vorlagenfunktionen ausgeführt werden.

Es gibt jedoch einen Haken: Wir können Vorlagenfunktionen nicht direkt als Typen übergeben. Stattdessen müssen wir einen Workaround mit Dummy-Strukturen verwenden.

Workaround mit Dummy-Strukturen

Der folgende Code veranschaulicht den Workaround:

<code class="cpp">template <typename T>
struct a {

    static void foo (T = T ())
    {
    }

};

template <typename T>
struct b {

    static void foo (T = T ())
    {
    }

};

struct SomeObj {};
struct SomeOtherObj {};

template <template <typename P> class T>
void function ()
{
    T<SomeObj>::foo ();
    T<SomeOtherObj>::foo ();
}

int main ()
{
    function<a>();
    function<b>();
}</code>

Die Dummy-Strukturen a und b dienen als Platzhalter für die Vorlagenfunktionen. Sie stellen eine Methode foo bereit, die in erster Linie nichts tut, um die Syntaxanforderungen zu erfüllen.

Die Funktionsvorlage akzeptiert einen Vorlagenparameter T, der den Typ der auszuführenden Vorlagenfunktion angibt. Anschließend wird foo für zwei verschiedene Objekttypen aufgerufen, SomeObj und SomeOtherObj.

Mit diesem Ansatz können wir generische Funktionen definieren, die auf flexible und typsichere Weise mit einer Reihe von Vorlagenfunktionen arbeiten.

Das obige ist der detaillierte Inhalt vonWie können wir eine generische Funktion in C schreiben, die Vorlagenfunktionen als Argumente akzeptiert?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!