Articles of déduction de type

Echec de la déduction d’argument de modèle lors de l’utilisation de parameters de modèle

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, […]

Le type déduction ne fonctionne pas

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: […]

C ++ obtention du type d’un constructeur

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, […]

Déduction de type C ++ 11 avec std :: function

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 […]

Type de modèle déduction avec Lambdas

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 […]

Déduction de types dans les fonctions basées sur des modèles et dans le quailifier const

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); […]

La déduction de modèle échoue lors de l’utilisation de std :: result_of

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 […]

types contradictoires déduits pour le paramètre ‘T’ pour référence universelle

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 […]

Ordre de déduction du type de modèle de fonction et des listes initiées

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 […]

Déduction de la fonction

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 […]