Je voulais créer un algorithme auxiliaire simple qui remplirait un conteneur, tel que std::vector , avec une progression géomésortingque (le premier terme est a , et le n ème terme est donné par a * pow(r, n-1) , où r est un rapport donné); J’ai créé le code suivant: #include #include #include template<template class Container, […]
J’ai le problème suivant. Quand j’essaye de comstackr le code suivant template T func( T t) { return t; } template void foo( std::function func ) { // … } int main() { foo( func ); return 0; } Je reçois l’erreur: no matching function for call to ‘foo’ foo( func ); ^~~~~~ /Users/arirasch/WWU/dev/xcode/tests/tests/main.cpp:18:10: note: […]
J’essaie de déduire les types de parameters du constructeur d’une classe. J’ai réussi à obtenir les types de paramètre pour les méthodes membres, mais mon approche échoue pour les constructeurs car elle repose sur l’obtention du type d’un pointeur sur la méthode membre. #include #include // Some type with a constructor struct foo { foo(int, […]
Même après avoir lu de nombreuses ressources en ligne et d’autres questions, y compris la déduction de type argument de modèle de type retour std :: function avec lambda et déduction automatique de type Argument et les fonctions lambda anonymes , j’ai du mal à exprimer clairement ce qui suit en c ++. Je voudrais […]
Le problème auquel je suis confronté est simple. Étant donné le code suivant: template auto CallIt( ReturnType( *method )( Args… ) ) { return method; } auto test = CallIt( [] ( int a, int b ) { return a > b; } ); L’erreur que je reçois (à l’aide de VS13 avec le compilateur […]
J’ai le morceau suivant de c ++ 11-code: #include struct object { void talk(const char* text) const { std::cout << "talk " << text << std::endl; } }; void makeItTalk(object& obj) { obj.talk("non-const"); } void makeItTalk(const object& obj) { obj.talk("const"); } template void f(P&& p) { makeItTalk(std::forward(p)); } int main() { const object obj; f(obj); […]
J’essaie de créer une fonction qui appelle et renvoie la valeur renvoyée d’une fonction passée en tant que paramètre de modèle: template typename std::result_of::type call_function(Function&& f) { return f(); } template typename std::result_of::type call_member_function(Function&& f, Class* instance) { return instance->*f(); } // // call site: // call_function(f); call_member_function(&F::f, &instance); Voici une version d’idéone: http://ideone.com/IYM10x (elle […]
Je teste la référence universelle avec le code suivant, template vector attach_(vector xs, T&& x) { xs.push_back(std::forward(x)); return xs; } int main() { int k = 2; attach_(std::move(vector{1,2,3}),k); //not OK attach_(std::move(vector{1,2,3}),(int&)k); //not OK attach_(std::move(vector{1,2,3}),(int)k); //OK attach_(std::move(vector{1,2,3}),2); //OK } et j’ai eu une erreur: no matching function for call to ‘attach_(std::remove_reference<std::vector >::type, int&)’ attach_(std::move(vector{1,2,3}),k); note: template […]
J’ai une question concernant la procédure de déduction de type de paramètre de modèle de fonction. Prenons cet exemple: #include #include #include #include #include int main() { std::ifstream file(“path/to/file”); std::vector vec(std::istream_iterator{file},{}); // <- This part return 0; } Si je comprends bien les choses, le second paramètre est de type std::istream_iterator et le constructeur par […]
Disons que nous avons un modèle de classe comme celui-ci: template class A { public: template A(F f, Args… args) { /* Do something… */ } }; Et maintenant je veux l’utiliser d’une certaine manière comme celle-ci: A a(::close, 1); Maintenant la question: est-il possible d’omettre le car un compilateur peut connaître cette information pour […]