Comment fonctionne std :: tie?

Je l'ai utilisé std::tiesans trop y réfléchir. Cela fonctionne donc je viens d'accepter cela:

auto test()
{
   int a, b;
   std::tie(a, b) = std::make_tuple(2, 3);
   // a is now 2, b is now 3
   return a + b; // 5
}

Mais comment fonctionne cette magie noire ? Comment un temporaire créé par le std::tiechangement aet b? Je trouve cela plus intéressant car c'est une fonctionnalité de bibliothèque, pas une fonctionnalité de langage, donc c'est certainement quelque chose que nous pouvons implémenter nous-mêmes et comprendre.

Afin de clarifier le concept de base, réduisons-le à un exemple plus basique. Bien que cela std::tiesoit utile pour les fonctions retournant (un tuple de) plus de valeurs, nous pouvons le comprendre très bien avec une seule valeur:

int a;
std::tie(a) = std::make_tuple(24);
return a; // 24

Ce que nous devons savoir pour aller de l'avant:

• std::tie construit et renvoie un tuple de références.
• std::tuple<int>et std::tuple<int&>sont 2 classes complètement différentes, sans lien entre eux, d' autres qu'ils ont été générés à partir du même modèle, std::tuple.

• tuple a un tuple operator=acceptant un tuple de types différents (mais le même nombre), où chaque membre est assigné individuellement - de cppreference :

  template< class... UTypes >
  tuple& operator=( const tuple<UTypes...>& other );

  (3) Pour tout i, assigne std::get<i>(other)à std::get<i>(*this).

La prochaine étape consiste à se débarrasser de ces fonctions qui ne font que vous gêner, afin que nous puissions transformer notre code en ceci:

int a;
std::tuple<int&>{a} = std::tuple<int>{24};
return a; // 24

L'étape suivante consiste à voir exactement ce qui se passe à l'intérieur de ces structures. Pour cela, je crée 2 types de Tsubstituant pour std::tuple<int>et Trsubstituant std::tuple<int&>, dépouillés au strict minimum pour nos opérations:

struct T { // substituent for std::tuple<int>
    int x;
};

struct Tr { // substituent for std::tuple<int&>
    int& xr;

    auto operator=(const T& other)
    {
       // std::get<I>(*this) = std::get<I>(other);
       xr = other.x;
    }
};

auto foo()
{
    int a;
    Tr{a} = T{24};

    return a; // 24
}

Et enfin, j'aime me débarrasser des structures toutes ensemble (enfin, ce n'est pas 100% équivalent, mais c'est assez proche pour nous, et assez explicite pour le permettre):

auto foo()
{
    int a;

    { // block substituent for temporary variables

    // Tr{a}
    int& tr_xr = a;

    // T{24}
    int t_x = 24;

    // = (asignement)
    tr_xr = t_x;
    }

    return a; // 24
}

Donc, fondamentalement, std::tie(a)initialise une référence de membre de données à a. std::tuple<int>(24)crée un membre de données avec une valeur 24et l'affectation affecte 24 à la référence de membre de données dans la première structure. Mais depuis que membre de données est une référence liée à a, que , fondamentalement , cède 24à a.

Cela ne répond en aucun cas à votre question, mais permettez-moi de le poster quand même car C ++ 17 est fondamentalement prêt (avec le support du compilateur), donc tout en vous demandant comment fonctionne le matériel obsolète, il vaut probablement la peine de regarder comment l'actuel, et future, la version de C ++ fonctionne aussi.

Avec C ++ 17, vous pouvez à peu près gratter std::tieen faveur de ce que l'on appelle les liaisons structurées . Ils font la même chose (enfin, pas la même chose , mais ils ont le même effet net), bien que vous ayez besoin de taper moins de caractères, cela n'a pas besoin de support de bibliothèque, et vous avez également la possibilité de prendre des références, si cela se trouve être ce que tu veux.

(Notez qu'en C ++ 17, les constructeurs effectuent la déduction d'arguments, ce qui make_tupleest devenu quelque peu superflu également.)

int a, b;
std::tie(a, b) = std::make_tuple(2, 3);

// C++17
auto  [c, d] = std::make_tuple(4, 5);
auto  [e, f] = std::tuple(6, 7);
std::tuple t(8,9); auto& [g, h] = t; // not possible with std::tie