Sowas wie typedef für Funktionen?



  • Hallo zusammen

    Ich kann ja mit typedef ein Klassentemplate spezialisieren und benennen. Jetzt möchte ich aber das Selbe mit einem Funktionstemplate machen. Geht das irgendwie?

    Ich kann sowas machen:

    template<typename T>
    class BlaBla
    {
    };
    
    typedef BlaBla<int> IntBlaBla;
    

    Was ich gerne möchte:

    template<typename T>
    T Function(T)
    {
    }
    
    typedef Function<int> IntFunction;
    


  • Mist, falsches Forum. 🤡



  • So wie bei nicht-template Funktionen auch:

    typedef int (*IntFunction)(int);
    


  • Dieser Thread wurde von Moderator/in Jochen Kalmbach aus dem Forum C++/CLI mit .NET in das Forum C++ verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • Ich habe einen anderen Weg gefunden. Blöde wird's, wenn man viele Funktionsparameter hat.

    template<typename T>
    T Function(T)
    {
    }
    
    int (*IntFunction)(int) = Function<int>;
    


  • Stoffel schrieb:

    Hallo zusammen

    Ich kann ja mit typedef ein Klassentemplate spezialisieren ...

    Vielleicht bin ich kleinlich, aber Du solltest das nicht "Spezialisierung" nennen (auch wenn man das durchaus so nennen könnte), weil man unter "Spezialisierung von templates" eigentlich etwas ganz Bestimmtes versteht (und eine Spezialisierung in diesem Sinne ist das nicht, was Du da tust).

    Was Du da in Deinem letzten Beispiel tust, ist auch kein "typedef", sondern die Deklaration und Initialisierung eines Funktionspointers (= Einer Variable, die auf eine Funktion verweisen kann). Du hast also nicht einen Typ in der Hand, sondern eine Variable (je nach scope eine globale)....
    Ich würde das was Du willst, überhaupt nicht machen. Bei Funktionstemplates gibt es die automatische template-Deduktion, die anhand der übergebenen Parameter die richtigen Typen bestimmt - das konterkariert man mit Deinem Unterfangen.

    Wenn Du es unbedingt brauchst (z.B. bei der Parametrisierung anderer templates ohne Fingerbruch), würde ich es in eine Klasse kapseln:

    template<typename T>
    T Function(T t) { return t}
    
    template<typename T>
    struct FunctionStruct {
       T operator()(T t) { return Function(t); }
    };
    
    typedef FunctionStruct<int> IntFunction;
    

    Gruß,

    Simon2.



  • Eigentlich möchte ich das Template nur benutzen, damit ich eine Funktion nicht für mehrere Typen einzeln implementieren muss. Der Anwender sollte eben nicht selbst das Template benutzen, sondern nur einige vordefinierte spezialisierungen des Funktionstemplates.



  • Dann solltest du das Template auch nicht offenlegen, sondern nur die Spezialisierungen, die du zulassen willst (Randfrage: Was soll der Sinn dahinter sein?).



  • CStoll schrieb:

    Dann solltest du das Template auch nicht offenlegen, sondern nur die Spezialisierungen, die du zulassen willst (Randfrage: Was soll der Sinn dahinter sein?).

    Ich bastle mir eine Inifile-Klasse. Da gibt es verschiedene Key-Typen, wie z.B. StringKey, BoolKey, DoubleKey. Zugegriffen wird auf diese über einen Key-Pointer (Polymorphie). Die Funktion, von der hier die Rede ist, soll eigentlich nur ein dynamic cast durchführen, und bei Erfolg die Adresse auf den Wert des Keys zurückgeben, wobei es für jeden Key-Type die passende geben muss. GetBoolValue, GetStringValue, etc.

    Wie würdest du denn das Template verstecken? in einen eigenen namespace tun?



  • Ich würde das Template in einem CPP-File implementieren und im Header nur die benötigten Spezialisierungen notieren.

    (das heißt, vermutlich würde ich mich darauf verlassen, daß dieser dynamic_cast<> sich nicht compilieren lässt, wenn der User einen falschen (nicht mit abtract_key verwandten) Datentyp anfordern will.)


Log in to reply