Tag: variadic-templates
Variadic templates sind Vorlagen, die nehmen eine variable Anzahl von Parametern.
variadic template parameter pack Erweiterung für Funktionsaufrufe
2 Antworten
Ich bin auf der Suche nach sowas: template< typename T> void func(T t) { } template< typename... Parms> void anyFunc( Parms... p) { func<Parms>(p)... ; //error func(p)... ; //error } Wenn der parameter pack expansion erfolgt innerhalb
Erstellen von statischen array mit variadischen templates
3 Antworten
Es war eine Antwort auf stackoverflow (ich kann nicht scheinen mehr zu finden) welche zeigten, wie ein variadic template kann verwendet werden, in C++11 zum erstellen eines statischen Arrays zur compile-Zeit: template <class T, T... args> struct
Wickeln Sie ein Funktionszeiger in C++ mit variadic template
3 Antworten
Die Frage Habe ich eine Reihe von C++ - Funktionen void f(), R g(T a), S h(U a, V b) und so weiter. Ich möchte schreiben, eine Vorlage-Funktion, die akzeptiert f, g, h und so auf als
So erstellen Sie eine Typ-Liste (für variadic templates), enthält n-mal die gleiche Art?
2 Antworten
Ich würde gerne meine Klasse template <class T, unsigned int n> class X; erstellen std::tuple enthält n mal den Typ T. Gibt es eine besonders nette Möglichkeit dafür? Gibt es auch einen schönen Weg, dies zu tun
Wie kombiniert man std::bind(), variadic-templates und perfect forwarding?
1 Antworten
Ich soll zum aufrufen einer Methode von einem anderen, durch eine Dritte Funktion, aber beide verwenden variadic-Vorlagen. Zum Beispiel: void third_party(int n, std::function<void(int)> f) { f(n); } struct foo { template <typename... Args> void invoke(int n, Args&&...
Template-template-Parameter und variadic templates mit gcc-4.4
2 Antworten
Ich bin mit gcc 4.4 auf Debian squeeze. Betrachten Sie den folgenden code. #include <map> #include <string> using std::map; using std::string; //Args lets the user specify additional explicit template arguments template <typename T, template <typename T, typename...
Wie passend leere Argumente pack in variadic template
3 Antworten
Habe ich code: template<typename T> void loadBrush_sub_impl() { //do some work here } template<typename T, typename... Targs> void loadBrush_sub() { loadBrush_sub_impl<T>(); loadBrush_sub<Targs...>(); } template<> void loadBrush_sub<void>() { } //BasicBrush, BinaryBrush, SketchBrush, BasicEraser and MaskBased are class loadBrush_sub<BasicBrush,
Simulieren variadic templates in c#
5 Antworten
Ist es ein bekannter Weg, um das variadic template-Funktion in c#? Beispielsweise würde ich gerne schreiben, die eine Methode mit einem lambda-Ausdruck mit einem beliebigen Satz von Parametern. Hier ist in pseudo-code würde ich gerne haben: void
Template Spezialisierung für eine leere parameter-pack
3 Antworten
Habe ich ein variadic template-Funktion die sich selbst aufruft, um zu bestimmen, die größte Zahl in einer Liste (konstituiert durch die templatized Argumente). Ich versuche eine Spezialisierung in dem der parameter-pack ist leer und so kann ich
Fehler mit variadiac Vorlage: "- parameter pack muss erweitert werden"
1 Antworten
Hier ein variadic template-Funktion, die ich geschrieben habe: template<class Container, class Value, class... Args> Value& insert(Container& c, Args&&... args) { c.emplace_back(args); return c.back(); } Wenn ich insert wie ich bin immer ein Fehler: list<int> lst; int& num
Eine bessere LOG () - makro mit template metaprogramming
2 Antworten
Einer typischen LOG () - makro-basierte logging-Lösung kann wie folgt Aussehen: #define LOG(msg) \ std::cout << __FILE__ << "(" << __LINE__ << "): " << msg << std::endl Dies ermöglicht es Programmierern, Daten reichen die Nachrichten über
Die Generierung einer Klasse pro variadic template-argument
4 Antworten
Ich habe eine template-Klasse, wo die einzelnen template-argument steht für eine Art von Wert das interne Berechnungen verarbeiten kann. Vorlagen (statt überladen von Funktionen) benötigt werden, da die Werte übergeben werden, da boost::any, und die Typen sind
make_unique nicht kompilieren
2 Antworten
Ich versuche zu erstellen und zu verwenden make_unique für std::unique_ptr, in der gleichen Weise std::make_shared existiert für std::shared_ptr hier beschrieben. Herb Sutter erwähnt die mögliche Umsetzung make_unique sieht wie folgt aus: template<typename T, typename ...Args> std::unique_ptr<T> make_unique(
Non-type-Variable Funktion templates in C++11
5 Antworten
Sah ich einen blog-post die verwendete nicht-Typ variadic templates (derzeit nicht unterstützt gcc, die nur durch das Geräusch). template <class T, size_t... Dimensions> struct MultiDimArray { /* ... */ }; Beispiel in der post kompiliert einwandfrei, aber
"Auspacken", ein Tupel zu nennen, eine matching-Funktion Zeiger
8 Antworten
Ich versuche zu speichern in einer std::tuple eine unterschiedliche Anzahl von Werten, die später verwendet werden als Argumente für einen Aufruf einer Funktion, Zeiger mit dem gespeicherten Typen. Habe ich ein Vereinfachtes Beispiel zeigt das problem, das
variadic template-Argumente Auspacken, typename
4 Antworten
Ich wollen zum entpacken der parameter pack in func (siehe Zeile A), aber es funktioniert nicht. Wie kann ich die entpacken innen func< > oder ändern Sie Zeile Ein nur? #include <iostream> using namespace std; void func()
Variadic templates
8 Antworten
Ich habe gesehen, eine Menge von verbindungen Einführung in die variadic-Vorlagen. Aber ich habe nie gesehen, kompilierbare Beispiel veranschaulicht diesen Ansatz. Könnte jemand mir einige links, in denen solche kompilierbare Beispiele können gefunden werden? InformationsquelleAutor der Frage
Schreiben variadic template-Konstruktor
4 Antworten
Vor kurzem fragte ich diese Frage, aber jetzt würde ich mag, um es zu erweitern. Ich schrieb die folgende Klasse: template <class T> class X{ public: vector<T> v; template <class T> X(T n) { v.push_back(n); } template
Wie bekomme ich die Argumenttypen einer Funktion ein Zeiger auf ein variadic template Klasse?
1 Antworten
Dies ist ein follow-up dieses problem: Generische functor für Funktionen mit beliebiger Argumentliste Habe ich diese functor-Klasse (vollständigen code siehe link oben): template<typename... ARGS> class Foo { std::function<void(ARGS...)> m_f; public: Foo( std::function<void(ARGS...)> f ) : m_f(f) {}
Ruft eine Funktion für jedes variadic template-argument und ein array
5 Antworten
So, ich habe einige Typ X: typedef ... X; und eine template-Funktion f: class <typename T> void f(X& x_out, const T& arg_in); und dann eine Funktion g: void g(const X* x_array, size_t x_array_size); Muss ich schreiben, ein
C2977: 'std :: tuple': zu viele Vorlagenargumente (MSVC11)
7 Antworten
Ich versuche zu bauen googletest mit Visual C++ 11, aber der folgende code verursacht einen Fehler template <typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9> void PrintTo(const
Eine Funktion mit variabler Anzahl von Argumenten mit bekannten Typen, dem C ++ 11-Weg
2 Antworten
Weiß ich ja schon stdarg.h Weg, um eine Funktion mit Variablen Argumenten in c++ diskutiert, wie hier zum Beispiel. Ich weiß auch c++11-standard hat variadic templates erklärt hier. Aber in den beiden oben genannten Systeme die wir
Wie kann ich über eine gepackte variadische Template-Argumentliste iterieren?
7 Antworten
Ich versuche, eine Methode zu finden, um die Iteration über eine a pack variadic template-argument-list. Nun wie bei allen Iterationen, müssen Sie eine Art von Methode zu wissen, wie viele Argumente werden in die Liste gepackt, und
Variadische Vorlagenvorlagen und perfekte Weiterleitung
3 Antworten
Diese Frage auf die Objekt-generator Muster hat mich zum nachdenken über Möglichkeiten zur Automatisierung. Im wesentlichen möchte ich automatisieren der Erstellung von Funktionen wie std::make_pairstd::bind1st und std::mem_fun so dass anstatt zu schreiben, eine andere Funktion für jede
Pretty-Print std :: Tupel
7 Antworten
Dies ist ein follow-up auf meine Vorherige Frage auf pretty-Print-STL-Containernfür die wir erarbeiten eine sehr elegante und komplett Allgemeine Lösung. In diesem nächsten Schritt würde ich gerne pretty-printing für std::tuple<Args...> mit variadic templates (also das ist streng
rekursive variadische Vorlage, um den Inhalt eines Parameterpakets auszudrucken
4 Antworten
Wie ist es möglich, erstellen Sie eine rekursive variadic template drucken Sie den Inhalt einer Parameter-pack? Ich versuche mit diesem, aber es nicht kompilieren: template <typename First, typename ...Args> std::string type_name () { return std::string(typeid(First).name()) + "
Template-Parameterpakete greifen auf den N-ten Typ und das N-te Element zu
5 Antworten
Der folgende Beitrag ist der erste Vorschlag, den ich gefunden für template-parameter packs. http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2004/n1603.pdf Seite 16, er spricht über die Einführung von zwei neuen Operatoren und <> für den Zugriff auf parameter pack-Elemente und parameter-pack-Typen. The
make_unique und perfekte Weiterleitung
6 Antworten
Warum gibt es keine std::make_unique Funktion Vorlage in der standard C++11-Bibliothek? Ich finde std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3)); ein wenig ausführlich. Wäre nicht die folgenden werden viel schöner? auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3); Diesem verbirgt new
Den Overhead von Lambda-Funktionen in C ++ verstehen 11
1 Antworten
War dies bereits berührt in Warum C++ lambda ist langsamer als eine normale Funktion, wenn Sie mehrfach aufgerufen wird? und C++0x-Lambda-overhead Aber ich denke, mein Beispiel ist etwas anders als die Diskussion in der ehemaligen und widerspricht
generischer Elementfunktionszeiger als Vorlagenparameter
1 Antworten
Betrachten Sie diesen code: #include <iostream> using namespace std; class hello{ public: void f(){ cout<<"f"<<endl; } virtual void ff(){ cout<<"ff"<<endl; } }; #define call_mem_fn(object, ptr) ((object).*(ptr)) template<R (C::*ptr_to_mem)(Args...)> void proxycall(C& obj){ cout<<"hello"<<endl; call_mem_fn(obj, ptr_to_mem)(); } int main(){
C ++ 11: Anzahl der variadischen Template-Funktionsparameter?
1 Antworten
Wie kann ich die Anzahl der Argumente, die ein variadic template-Funktion? ie: template<typename... T> void f(const T&... t) { int n = number_of_args(t); ... } Was ist der beste Weg zur Umsetzung number_of_args im oben genannten? InformationsquelleAutor
Ist es möglich, ein Template-Parameterpaket zu "speichern", ohne es zu erweitern?
4 Antworten
Ich war das Experimentieren mit C++0x-variadic-templates, wenn ich stolperte über dieses Problem: template < typename ...Args > struct identities { typedef Args type; //compile error: "parameter packs not expanded with '...' }; //The following code just shows
Wie speichert man variadische Template-Argumente?
3 Antworten
Ist es möglich, einem parameter-pack irgendwie für eine spätere Verwendung? template <typename... T> class Action { private: std::function<void(T...)> f; T... args; //<--- something like this public: Action(std::function<void(T...)> f, T... args) : f(f), args(args) {} void act(){ f(args);
Erweiterung des Variadic-Vorlagenpakets
5 Antworten
Ich versuche zu lernen variadic templates und Funktionen. Ich kann nicht verstehen, warum dieser code nicht kompilieren: template<typename T> static void bar(T t) {} template<typename... Args> static void foo2(Args... args) { (bar(args)...); } int main() { foo2(1,
C ++ 11 Variadischer Std :: Funktionsparameter
4 Antworten
Einer Funktion namens test nimmt std::function<> als parameter. template<typename R, typename ...A> void test(std::function<R(A...)> f) { //... } Aber, wenn ich den folgenden Code: void foo(int n) { /* ... */ } //... test(foo); Compiler(gcc 4.6.1) sagt
Wie kann ich mehrere Parameterpakete in einer variadischen Vorlage haben?
2 Antworten
Funktion () akzeptiert einen parameter packen. Funktion zwei() akzeptiert zwei. Jedes pack ist eingeschränkt, verpackt in Arten Eine und B. Warum ist es unmöglich zu instanziieren zwei()? template <typename T> struct A {}; template <typename T> struct