C++ Wie auf Vorgefertigte Funktionen, die mit std::bind / std::function

Wenn Sie eine vorgefertigte Klasse oder eine Vorlagen-Funktion (oder Kombination aus beiden), wie binden Sie diese Funktion, (die Erhaltung der template-parameter type)?

Bekam ich etwas Hilfe, um die grundlegende syntax in einem post weiter unten zu binden, um Funktionen mit expliziten template-type-Parameter, verlieren aber die Fähigkeit, template type Parameter in den Prozess.

Ist es möglich, diese so zu arbeiten, dass es noch möglich ist, eine Vorlage-Typ-Parameter mit Zukunft ruft?

Gereinigt bis dieser code viel, aber es wird offensichtlich nicht kompilieren, weil ich nicht finden können, die richtige syntax (gibt es irgendwelche Möglichkeiten, dies zu tun)?

Entfernt die "vector" - Anforderung zu vereinfachen:

Danke für die Hilfe!

#include <functional>
#include <vector>
#include <string>

/***************************************/
template <typename CommandTemplateType>
class Storage
{
  public:
   //No idea how to define this vector to allow Template Parameters
   //static std::vector<std::function<void<ParameterTemplateType>
   //    (std::shared_ptr<ParameterTemplateType>)>> Functions;

   //I really don't need the collection, a single member would kick start my research:
   static std::function<void<ParameterTemplateType>(std::shared_ptr<ParameterTemplateType>)> Function;

  template <typename ParameterTemplateType>
  static void Execute(ParameterTemplateType parameter)
  {
     //Look up index, or loop through all.. 
     //I am trying to invoke the bound function with a template param:
     //Functions[index]<ParameterTemplateType>(parameter);
     //preferably, just:  
     Function<ParameterTempalteType>(parameter); 
  }
};

/***************************************/
template <typename TemplateType>
class MyClass
{

   template <typename ParameterTemplateType>
   void MyFunction(ParameterTemplateType myParameter)
   {
     //Do something; 
   }

   MyClass()
   {
      std::string parameter = L"Test String";

      //Do not know how to include the 
      //template<typename ParameterTemplateType> definition to bind call.
      //Storage::Functions.push_back(
      //    std::bind(&MyClass::MyFunction<ParameterTemplateType>,
//       this, std::placeholders::_1));

     //Or just something like:
     Storage::Function = std::bind(&MyClass::MyFunction<ParameterTemplateType>,
                             this, std::placeholders::_1));

      /***************************************/
      //Call the bound function with an explicit parameter somehow:
      std::string parameter = L"Test String";          
      Storage::Execute<std::string>(parameter);


   }
};
  • Was wollen Sie übergeben werden, als myParameter?
  • Anmerkung zur Terminologie: es gibt keine solche Sache wie eine "vorgefertigte Klasse/Funktion". Es gibt Klassen-templates und Funktions-templates. Das ist ein ganz fundamentaler Unterschied: es ist nicht so, dass etwas (eine "Vorlage", was immer das ist) wird auf eine Klasse angewendet. Es ist Umgekehrt: eine Klasse Vorlage selbst ist eine Vorlage, ein Modell oder eine Form, aus dem erstellen einer konkreten Klasse (durch einfügen von template-Argumente). Denken Sie an eine Klasse Vorlage, wie ein Schimmel, von dem aus ein Schwert (= Klasse), nicht wie ein Schwert, mit einigen Verzierungen auf Sie.
  • Wenn ich verstehe, was du fragst richtig, es ist unmöglich. std::bind ist ein run-time-Konzept, Rückgabe von (im wesentlichen) eine Funktion, die aufgerufen werden können. Die Instanziierung einer Funktion Vorlage (ausfüllen der Vorlage-parameter) werden muss, geschieht bei der Kompilierung. Sie kann nicht laufen-Zeit binden, um eine Funktion, die (möglicherweise) noch kompiliert werden müssen...
  • Ich fand heraus, wie es zu tun. Sie haben, um wickeln Sie die Vorlagen-Funktion in eine vorgefertigte container von einer Art sein. Habe ich geschrieben, die Antwort unten. Vielen Dank an alle für all die Hilfe!
InformationsquelleAutor |
  1. 12

    Der zentralen Themen ist, die in C++11 kann man nicht tun, sowas wie:

    //Doesn't compile
template <typename TemplateType>
static std::function<void(std::shared_ptr<TemplateType>)> Function;

    Klassen und Funktionen sind vorgefertigte, aber nicht die Eigenschaften.

    Die "Magie" ist:

    /*******************************************************************/
//Define a Function Pointer in a Container
class Storage
{
   template <typename TemplateType>
   struct FunctionContainer {
       static std::function<void(std::shared_ptr<TemplateType>)> Function;
   };
};
/*******************************************************************/
//Initialize FunctionContainer's Static Function Pointer if using static pointer.
template <typename TemplateType>
std::function<void(std::shared_ptr<TemplateType>)> Storage
    ::FunctionContainer<TemplateType>::Function;

    Können Sie Binden Sie dann eine Vorlagen-Funktion um diese Funktion wie:

    //Bind Function Pointer in Container to a Local Function
class MyClass
{
   template <typename TemplateType>
   void MyFunction(std::shared_ptr<TemplateType> parameter)
   {
     //Do something.
     //You can make this templated or non-templated.
   }
   MyClass()
   {
     //If you really want, you can templatize std::string in the following:
     Storage::FunctionContainer<std::string>::Function 
       = std::bind(&MyFunction<std::string>, this, std::placeholders::_1);
   }
}

    Und Sie aufrufen können all dies und bieten eine vorgefertigte parameter "type" wie folgt:

    //Invocation
std::shared_ptr<std::string> parameter;
parameter->get() = "Hello World".
Storage::FunctionContainer<std::string>::Function(parameter);
    • Nie gesehen so ein Konstrukt vor: parameter->get() = "Hello World". was macht das?
    • Hi! std::shared_ptr<>.get() ist nur C++ API-Methode ist, dass nur ein Verweis auf das std:shared_ptr ist "Zeiger" (cplusplus.com/reference/memory/shared_ptr) ... Einfach zuweisen den Wert der Zeichenfolge "Hallo Welt", wie der Wert der shared pointer. Ich habe nicht bearbeitet, meine Frage in eine Weile, um es zu säubern, und so wie es aussieht sollte ich das tun! Danke!
    InformationsquelleAutor
  2. 10

    Den template-argument für std::function sollte die Signatur der Funktion nach template-type substitution durchgeführt wurde. In Ihrem Fall, weder TemplateType noch FunctionTemplateType haben einen Effekt auf die Signatur der Memberfunktion MyFunction - es wird immer wieder ein std::string und nehmen Sie ein einzelnes std::string argument. Daher die std::function Sie gehen, um Geschäft in Ihrer std::vector werden sollte:

    static std::vector<std::function<std::string(std::string)>> Functions;

    Daran erinnern, dass eine Elementfunktion hat einen impliziten ersten argument this. Sie zu binden, müssen Sie das erste argument des MyClass<...>::MyFunc<...> zu dem Objekt, das Sie aufrufen möchten, auf. Vermutlich, da man bindet die Funktion in MyClass's Konstruktor, der Sie das Objekt haben möchten, dass MyClass Instanz. Das bedeutet, dass Ihre push_back sollte wie folgt Aussehen:

    Storage::Functions.push_back(
  std::bind(&MyClass<TemplateType>::MyFunction<int>, this,
    std::placeholders::_1)
);

    Nun die Funktion, die geschoben wird, ist in Functions gebunden ist, um Ihre MyClass Objekt und übernimmt ein einzelnes argument des Typs std::string. Ruft man diese Funktionen so auf:

    Storage::Functions[0]("something");
    • Danke!!! Kann ich dieses rufen von außerhalb der Klasse? Wie, wenn ich weiß, die parameter: class Aussen { void Do(CustomClass * stuff) { Storage::Funktionen[finden Sie die richtige Signatur](stuff);}};
    • Was ist, wenn ich schob diese Funktion in den Vektor von innerhalb eines funktors mit so etwas wie Storage::Funktionen.push_back(std::bind( diese ..... // )
    • ist eine Instanziierung Ihre Funktion. Die & ("Adresse") gibt man ein Zeiger auf member-Funktion, die ähnlich wie ein Funktions-pointer, aber die Funktion, die Punkte müssen genannt werden, die auf ein bestimmtes Objekt. Member-Funktionen werden immer für ein Objekt aufgerufen, es sei denn, Sie sind statisch.
    • sorry, <nichts> ... ist das ein Stichwort? Nicht zu sehen, wie die Zeiger weiß über den parameter-Typ ..
    • Nun, was bedeutet bind tun, um diese Funktion? Alle Argumente nach dem Zeiger auf member-Funktion sind Argumente, sollte bound, um die Argumente dieser Funktion. Ihre MyFunction hat zwei Argumente: das erste ist die implizite this argument, dass jedes Mitglied-Funktion hat, und die zweite ist die std::string. So binden wir das aktuelle Objekt this dem ersten argument und, indem Sie einen Platzhalter verwenden, sagen wir das andere argument (die std::string sollte ungebunden. Nun die Funktion, dass bind gibt nur ein argument, das std::string.
    • ist das gleiche <anything> gab ich in meiner Antwort. Deine ursprüngliche Frage hatte einen FunctionTemplateType hatte keine Auswirkungen auf irgendetwas. Ich war nur zu sagen, Sie könnten jede Art für sich, dass - anything ist nicht etwas bestimmtes. Könnte es sein int, Foo, was auch immer.
    • lassen Sie uns weiter, diese Diskussion im chat
    • Sie erwähnt: std::bind(&MyClass<TemplateType>::MyFunction<int>, this, std::placeholders::_1) .. Was, wenn ich angeben will den TemplateType, aber verlassen wollen MyFunction<int> noch templatable, so dass die Funktion kann noch genannt werden, mit einer Vorlage? Funktionen[0]<std::string>("MyString"); ? Gibt es std::placeholders::_? für Template-Parameter?
    • Immer noch versuchen, herauszufinden, wie etwas zu tun wie: Lagerung::Funktionen[0]<std::string>("etwas");

    InformationsquelleAutor Joseph Mansfield
  3. 5

    Wenn ich Sie richtig verstanden... 🙂

    Was Sie tun möchten ist nicht möglich, da für template<class T> void foo(T) - Funktionen foo<int>() und foo<double> sind von verschiedenen Arten und Sie können nicht erstellen Sie Vektor-holding Zeiger auf Funktionen, die direkt durch Vektor homogene container.

    Zu überwinden, können wir die Verwendung von boost::variant<> entweder speichern von Pointern, die verschiedenen Arten von Funktionen oder zum speichern von Argumenten von Funktionen.

    template<class T> void foo(T);
typedef boost::variant<void (*)(int), void (*)(double)> func_ptr_variant;
std::vector<func_ptr_variant> v;
v.push_back(foo<int>);
v.push_back(foo<double>);

typedef boost::variant<int, double> argument;
std::vector<void (*)(argument)) v;
v.push_back(foo);
v.push_back(bar);
//foo and bar are defined as void foo(argument a) and void bar(argument a)

    Leider, in jedem Fall müssen Sie instanziieren Funktion Vorlagen, bevor Sie Sie in container, weil C++ nicht machen kann, code-Generierung on-the-fly. Ich denke, dass es möglich ist, dass Sie wissen, alle möglichen Arten von Argumenten, die Funktion kann verwendet werden, so dass möglicherweise nicht ein problem.

    • Was nicht mit den Vektor dann? Ich auskommentiert alle Verweise zu Vektor ..
    • Speichern nur eine einzige Variante, in der alle möglichen Instanziierungen von Funktionen.
    InformationsquelleAutor
  4. 4

    MyClass c-tor-weiß nicht, nichts über FunctionTemplateType deshalb kann es push_back nur explizite spezialisiert (sorry, es ist ein Ausdruck von mir... ich weiß nicht den richtigen Begriff), wie Sie in dieser

    #include <functional>
#include <vector>
#include <string>

struct Storage
{
  //Have no idea what this signature should really be:
  static std::vector<std::function<void ()>> Functions;

};
std::vector<std::function<void ()>> Storage::Functions;

template <typename TemplateType>
class MyClass
{
   template <typename FunctionTemplateType>
   std::string MyFunction(std::string myParameter)
   {
     return "Hellö: " + myParameter;

   }
public:
   MyClass()
   {
      Storage::Functions.push_back(
          std::bind( & MyClass<TemplateType>::MyFunction<std::string>, this, "borisbn" )
//                                                      ^^^^^^^^^^^
      );
   }
};

int main() {
    MyClass<int> obj;
}

    liveworkspace link

    InformationsquelleAutor borisbn
Schreibe einen Kommentar