Discussion :

[aperikub]

bonjour à tous,
je cherche un moyen de récupérer les types de la clé et de la valeur associée d'un unordered_map. par exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
#include <string>
#include <unordered_map>
 
int main()
{
 
    std::unordered_map<type 1, type 2> foo
    {
       { clé1, valeur1 },
       { clé2, valeur2 }
        [etc..]
    };
 
//si je veux créer une boucle for qui accepte d'autres unordered_map avec des types différents j'aurais tendance à essayer quelque chose dans ce genre la:
 
    for (std::pair<decltype(qu'est-ce que je met la?), decltype( et la?)> paire : foo)
    {
        std::cout << paire.first << std::endl << paire.second;
    }
 
    return 0;
}

du coup est-ce que c'est possible, et si oui comment?
merci d'avance!

[aperikub]

du coup j'ai trouvé un moyen:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
std::unordered_map<type 1, type 2> foo
    {
       { clé1, valeur1 },
       { clé2, valeur2 }
        [etc..]
    };
 
for (std::pair<decltype(foo.begin()->first), decltype( foo.begin()->second)> paire : foo)
    {
        std::cout << paire.first << std::endl << paire.second;
    }

est-ce qu'il y a une meilleure façon de faire?

[Invité]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (decltype(foo)::value_type paire : foo)

ou encore

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

for (auto paire : foo)

[aperikub]

ah nickel! j'avais vu value_type dans la doc mais je ne trouvais pas comment m'en servir (j'ai pas encore vu la poo). du coup les member types s'utilisent toujours avec l'opérateur de portée?

[Invité]

En général oui, on met le type puis l'opérateur de portée puis le member type.
Si on est déjà dans l'espace de nom ce n'est pas nécessaire (cf exemple suivant) mais c'est un peu particulier.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <iostream>
#include <unordered_map>
 
using umap = std::unordered_map<int, double>;
 
struct mymap : umap {
    mymap(std::initializer_list<value_type> init) : umap(init) {}
 
    void print() {
        for (const value_type & p : *this)
            std::cout << p.first << " -> " << p.second << std::endl;
    }
};
 
int main() {
    mymap foo { {1, 5.4}, {2, 3.7} };
 
    foo.print();
 
    for (const mymap::value_type & p : foo)
        std::cout << p.first << " -> " << p.second << std::endl;
 
    return 0;
}

[aperikub]

oulah je comprends pas vraiment ton exemple, je suis le cours de c++ moderne sur zeste de savoir et il y à beaucoup de notions que j'ai pas encore vu

initializer_list: j'ai été voir la doc ça ne m'a pas beaucoup éclairé, using: je ne l'utilise que pour using namespace std, et encore, le cours n'a pas encore couvert ce sujet, je ne connais pas non plus cette façon d'utiliser les structures avec les deux points:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

struct mymap : umap {

[Invité]

oulah je comprends pas vraiment ton exemple, je suis le cours de c++ moderne sur zeste de savoir et il y à beaucoup de notions que j'ai pas encore vu

Ah ok. C'est pas grave si tu comprends pas encore bien cet exemple, il y a des notions plus importantes à apprendre d'abord.

initializer_list: j'ai été voir la doc ça ne m'a pas beaucoup éclairé,

C'est juste pour pouvoir faire mymap foo { {1, 5.4}, {2, 3.7} };.

using: je ne l'utilise que pour using namespace std, et encore, le cours n'a pas encore couvert ce sujet

Ici, c'est pour définir un alias (umap) et éviter d'avoir à écrire unordered_map<int, double>. Par contre using namespace std, c'est souvent considéré comme une mauvaise pratique.

je ne connais pas non plus cette façon d'utiliser les structures avec les deux points:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

struct mymap : umap {

C'est juste de l'héritage (mymap dérive de umap). En gros c'est comme avec les classes sauf que tous les droits sont "public".

[Bousk]

En C++17 for (const auto& [key, value] : map)

[aperikub]

ok merci pour les clarifications, mais pour l'instant ça me passe loin au dessus de la tête, ce sera surement plus clair quand j'aurais vu les classes.

En C++17 (const auto& [key, value] : map)

késako? la boucle for? si je posais la question c'est parce que j'aime pas utiliser auto sans savoir comment faire "à la main".

[koala01]

Salut,

ok merci pour les clarifications, mais pour l'instant ça me passe loin au dessus de la tête, ce sera surement plus clair quand j'aurais vu les classes.



késako? la boucle for? si je posais la question c'est parce que j'aime pas utiliser auto sans savoir comment faire "à la main".

La forme for(type valeur : container) est ce que l'on appelle une "boucle basée sur les intervalles".

De manière générale, c'est une boucle qui peut s'appliquer sur tout ce qui est capable de fonctionner avec les fonctions libres std::begin() et std::end (ou leur équivalent en fonctions membres).

Autrement dit, avec toutes les collections de la bibliothèque standard (et avec de nombreuses collections de bibliothèques régulièrement utilisées).

Le mot clé auto est le mot clé utilisé pour ce que l'on appelle "l'inférence de type".

Pour faire simple: chaque fois que tu as affaire à une abstraction, que tu t'intéresse d'avantage à l'abstraction représentée par la donnée qu'à son type réel (qui pourrait très bien évoluer avec le temps), cela te permet de garder un code plus évolutif, plus "générique", que si tu utilisais le type réel de la donnée. Je l'explique:

Mettons que tu veuille parcourir l'ensemble des éléments qui se trouvent dans une collection quelconque. La notion qui correspond à "un élément qui permet de passer au suivant" est la notion d'itérateur.

Seulement, le type de l'itérateur dépend normalement du type de la collection dans laquelle l'élément est placé, et de la manière dont tu souhaites accéder à cet élément (comprends: sous une forme constante ou non constante).

Ainsi, si tes éléments sont placés dans un std::vector, le type réel de l'itérateur sera std::vector<TypeDeLaDonnee>::/*const_*/iterator mais, si tu décide de changer de collection et d'utiliser un std::set, le type de l'itérateur sera std:::st<TypeDeLaDonnee>::/*const_*/iterator.

Et si tu utilises Qt, et que tu décides d'utiliser une QList, le type de l'itérateur sera QList<TypeDeLaDonnee>::/*const_*/iterator.

Le fait est que tu te fous pas mal du type de la collection dans laquelle seront placés les différents éléments. Tu as bien conscience que certaines collections seront sans doute plus efficaces pour te donner l'accès aux éléments, que d'autres te donneront un accès trié (ou non), mais cela n'a aucune espèce d'incidence sur la logique à suivre: ce que toi tu veux, c'est d'être sur de passer tous les éléments de la collection en revue.

Tu vas donc utiliser "l'inférence de type" (et son mot clé auto) pour dire au compilateur quelque chose comme

Tu es tout à fait capable de déterminer le type réel de la donnée qui sera renvoyée par les fonctions (begin() et end(), dans le cas présent) qui seront appelée pour parcourir la collection (quelle qu'elle soit), alors, fais moi pas ch...er à me demander d'écrire ce type en entier, parce que c'est très long à écrire, et que cela peut changer avec le temps

Tu pourrais, par exemple, utiliser l'inférence de type sur une boucle "classique" du genre de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
for(auto iterator = collection.begin(); iterator != collection.end(); ++it){
    /* tu manipule iterator ici
     * passera tous les éléments de la collection en revue
     */
}

Mais cela reste encore fort long à écrire, car, depuis C++11, on dispose des boucles basées sur les intervalles dont j'ai parlé plus haut, et que, du coup, tu peux te contenter d'une boucle proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
for(auto iterator : collection){
    /* tu manipule iterator ici
     * passera tous les éléments de la collection en revue
     */
}

Reste, enfin, le cas particulier des /* unordered_*/map. Car ce type de collection renvoie en réalité une pair "clé / valeur" et que donc, l'accès à ces deux données se fait "théoriquement" sous la forme de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
iterator->first /* accède à la valeur représentée par la clé */;
iterator->second /* accède à la valeur représentée par la valeur */;

le tout, avec certaines restriction sur le type de donnée qui représente la clé, à savoir:

• que la clé est "immuable" (on ne peut pas modifier la clé directement)
• que la clé doit pouvoir répondre favorablement à l'inégalité "est plus petit que" pour permettre le tri

Depuis C++ 17, il y a moyen de nommer les données que l'on récupère "par lot", car il ne faut pas oublier que "nommer, c'est créer", et que si on appelle explicitement une donnée key (ou cle) et que l'on appelle explicitement l'autre donnée value (ou valeur), l'usage auquel les deux données vont servir sera beaucoup plus clair pour tout le monde que si on se contentait de iterator->first et iterator->second et que, du coup, le code devient beaucoup plus facile à comprendre

On pourra donc profiter "intelligemment" de l'inférence de type et des boucles basées sur les intervalles en écrivant un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
for(auto [key, value] : // je récupère une donnée qui sert de clé et une donnée qui  sert de valeur
                       collection /* dans la collection nommée collection */ ){
    /* j'utilise key pour accéder (en lecture seule) à la valeur de la clé
     * j'utilise value pour accéder (en lecture écriture au besoin) à la donnée qui représente la valeur
     * je parcours l'ensemble des éléments qui se trouvent dans collection
     */
}

Avec un tel code code, aussi longtemps que les fonctions utilisées (begin() et end(), dans le cas présent) renverront effectivement une clé et une valeur, mon code pourra effectivement fonctionner sans modification.

Et si, un jour, je décide de changer le type de la collection qui contient les éléments que je souhaite parcourir, et que la notion de clé n'a "plus de raison d'être" -- à l'occasion d'un refactoring majeur -- je sais exactement comment je devrai modifier le code en question

[aperikub]

Depuis C++ 17, il y a moyen de nommer les données que l'on récupère "par lot", car il ne faut pas oublier que "nommer, c'est créer", et que si on appelle explicitement une donnée key (ou cle) et que l'on appelle explicitement l'autre donnée value (ou valeur), l'usage auquel les deux données vont servir sera beaucoup plus clair pour tout le monde que si on se contentait de iterator->first et iterator->second et que, du coup, le code devient beaucoup plus facile à comprendre

On pourra donc profiter "intelligemment" de l'inférence de type et des boucles basées sur les intervalles en écrivant un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
for(auto [key, value] : // je récupère une donnée qui sert de clé et une donnée qui  sert de valeur
                       collection /* dans la collection nommée collection */ ){
    /* j'utilise key pour accéder (en lecture seule) à la valeur de la clé
     * j'utilise value pour accéder (en lecture écriture au besoin) à la donnée qui représente la valeur
     * je parcours l'ensemble des éléments qui se trouvent dans collection
     */
}

Avec un tel code code, aussi longtemps que les fonctions utilisées (begin() et end(), dans le cas présent) renverront effectivement une clé et une valeur, mon code pourra effectivement fonctionner sans modification.

Et si, un jour, je décide de changer le type de la collection qui contient les éléments que je souhaite parcourir, et que la notion de clé n'a "plus de raison d'être" -- à l'occasion d'un refactoring majeur -- je sais exactement comment je devrai modifier le code en question

merci beaucoup d'avoir pris le temps, du coup si j'ai bien compris quand on fait:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

const auto& [key, value] : collection

key et value ne sont pas des mots clés du langage C++ (comme first ou second) mais on crée les variables key et value (contenues dans un std::pair?) qui vont récupérer les éléments de la collection mais qu'on aurait tout aussi bien pu appeler [tagada, tsointsoin]

[koala01]

key et value ne sont pas des mots clés du langage C++ (comme first ou second)

Attention, first et second ne sont absolument pas des mots clé : c'est le nom donné aux deux données membre qui composent une std::pair (tout comme tu appelerait les données qui composent un point x et y )

Pour être précis, std::pair est l'abstraction ultime de tout ce qui peut être composé ... de deux données dont on ignore tout:

1. c'est une structure template, qui permet de choisir n'importe quel type pour chacune de ces deux données
2. Et comme on ne sait pas à quoi serviront ces données mais qu'il faut bien leur donner un nom, ils ont choisi les noms les plus génériques possibles: first, qui représente la première donnée de la structure et second, qui représente la deuxième donnée

Dans le cas du code que j'ai donné plus haut, et que je reprend ici

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
for(auto [key, value] : collection){
 
}

la partie [key, value] indique que je m'attend à recevoir deux données distinctes que je choisi d'appeler, dans le cadre de l'utilisation que je prévois d'en faire "key" (clé, en anglais) et "value" (valeur, en anglais)

mais on crée les variables key et value

oui, c'est bien cela

(contenues dans un std::pair?)

En fait, cela va même beaucoup plus loi que cela, car tu peux "binder" à peu près n'importe quel type POD (Plain Old Data : les bonnes vieilles structure "à l'ancienne"):

Ainsi, un code proche de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
struct point{
    int x;
    int y;
    int z;
};
point giveMeAPoint(){
    return  {4,5,6};
}
int main(){
    auto [a, b, c] = giveMeAPoint();
    std::cout<<a<<" "<< b <<" "<< c<<"\n";
}

réagira exactement comme on est en droit de l'attendre, en t'affichant les valeur 4,5,6

(pour être complet, j'ajouterai juste que c'est ce que l'on appelle un "binding" )

qu'on aurait tout aussi bien pu appeler [tagada, tsointsoin]

Êxactement... A ceci près que tagada et tsointsoin ne donneront pas vraiment d'information intéressante sur la manière dont tu prévois de les utiliser

[aperikub]

Attention, first et second ne sont absolument pas des mots clé : c'est le nom donné aux deux données membre qui composent une std::pair (tout comme tu appelerait les données qui composent un point x et y )

désolé je suis encore un peu balbutiant au niveau vocabulaire, ce que j'entendais par mots clés c'est toutes les expressions déjà définies dans le langage (que ce soit des variables, des fonctions, des membres ou autre) comme break, for, class, bool, etc...
en tout cas merci beaucoup d'avoir pris le temps de m'expliquer, je connaissais pas les bindings (à part peut-etre std::tie qui me semble être de la même veine).

[koala01]

désolé je suis encore un peu balbutiant au niveau vocabulaire, ce que j'entendais par mots clés c'est toutes les expressions déjà définies dans le langage (que ce soit des variables, des fonctions, des membres ou autre) comme break, for, class, bool, etc...

En fait, un mot clé est un mot qui a un sens bien défini dans le langage, et que tu ne peut donc pas choisir comme nom pour identifier l'un de tes concepts.

Il y a, à ce jour, 96 mots clés définis pour le C++. Tu les trouveras tous ==>ICI<==.

Les noms de fonctions, de types et de paramètres (voire, des paramètres templates), ne font pas partie du langage à proprement parler, car ils font partie d'une bibliothèque, et leur nom a été choisi en fonction de l'usage auquel on destine l'élément nommé

... (à part peut-etre std::tie qui me semble être de la même veine).

HeHe... Ca ne fait pas que sembler être de la même veine: c'est,à quelques détails près exactement la même chose

La grosse différence, c'est que std::tie est une fonction issue de la bibliothèque standard (comme l'indique le préfixe std: qui nécessite l'inclusion du fichier d'en-tête <tuple> et qui renvoie un élément de type std::tuple ( pour lequel les opérateurs de comparaisons == et <, à tout le moins, sont clairement définis), alors que le binding à l'aide des [] est une fonctionnalité fournie par le langage.

[aperikub]

je marque le sujet comme résolu, merci encore!