Prenez l’extrait suivant pour tester les déclarations de décomposition de fonctionnalités C ++ 17 à venir (anciennement appelées liaisons structurées). #include #include constexpr auto divmod(int n, int d) { return std::make_pair(n / d, n % d); // in g++7, also just std::pair{n/d, n%d} } int main() { constexpr auto [q, r] = divmod(10, 3); static_assert(q […]
Est-ce que l’écriture const auto& [a, b] = f(); garantir l’extension de la durée de vie de l’object renvoyé par f() , ou au moins les objects a et b sont liés? En lisant la proposition, je ne vois rien d’évident dans le libellé qui me permette de le vérifier, à moins que cela ne […]
Prenons un exemple: #include #include #include int main() { auto tup = std::make_tuple(1, 2); auto [ a, b ] = tup; decltype(auto) e = a; std::cout << std::boolalpha << std::is_reference_v << std::endl; } clang (sortie: false ) et gcc (sortie: true ) sont en désaccord dans ce cas simple. Par exemple, ces questions-réponses devraient-elles constituer […]
La norme C ++ 17 introduit une nouvelle fonctionnalité de liaisons structurées , initialement proposée en 2015 et dont l’aspect syntaxique a été largement discuté plus tard. Certaines utilisations viennent à l’esprit lorsque vous parcourez la documentation. Décomposition des agrégats Déclarons un tuple: std::tuple t(42, “foo”); Des copies élémentaires nommées peuvent être facilement obtenues avec […]
Cette réponse SO répertorie certaines lacunes des déclarations de décomposition C ++ 17 (la fonction anciennement appelée “liaison structurée”). Par exemple, vous ne pouvez pas donner de types explicites aux nouvelles variables, etc. Mais une grosse lacune que je rencontre n’est pas mentionnée ici, alors je me demande s’il existe une solution de contournement connue […]
Hier, j’ai vu une question intéressante à propos de SO concernant la liaison structurée. Nous pouvons le résumer comme suit. Prenons l’exemple de code ci-dessous: #include #include int main() { auto tup = std::make_tuple(1, 2); auto & [ a, b ] = tup; // the following line won’t comstack for a isn’t a reference // […]
À ma connaissance, les identificateurs introduits par les liaisons structurées dans C ++ 17 font en réalité référence à une variable “cachée”. Tel que auto [ a, b ] = std::make_tuple(1, 2); est un peu équivalent à auto e = std::make_tuple(1, 2); auto& a = std::get(e); auto& b = std::get(e); Cependant, si std::is_reference::value , j’obtiens […]
En lisant ce résumé des dernières fonctionnalités du c ++ 17, j’ai été un peu surpris par la section sur les liaisons structurées (c’est moi qui souligne): liaisons structurées Jusqu’à présent, il était connu d’utiliser un truc pour abuser de std :: tie afin d’affecter directement un tuple ou une paire à différentes variables, au […]
Est-il possible de déterminer combien de noms de variables dois-je spécifier entre crochets à l’aide de la syntaxe des liaisons structurées afin de faire correspondre le nombre de données membres d’une struct droite? Je veux faire une partie de la bibliothèque générique, qui utilise des liaisons structurées pour décomposer des classes arbitraires en ses constituants. […]
J’ai écrit un ensemble de classes pour permettre une fonction zip simple, de type python. L’extrait suivant fonctionne (presque) exactement comme prévu. Cependant, les deux variables a et b ne sont pas const . std::vector v1{0.0, 1.1, 2.2, 3.3}; std::vector v2{0, 1, 2}; for (auto const& [a, b] : zip(v1, v2)) { std::cout << a […]