Discussion :

[MrBidule]

edit : je pensais poster sur le forum débutant. Je ne sais comment migrer mon message vers c++->débutant. Désolé pour la pollution :/

Bonjour à tous,

Je tâtonne sur c++ depuis quelques semaines et j'avoue qu'il est assez gratifiant de progresser petit a petit avec des buts simples.
Jusqu'à présent je me suis servis de divers tutoriaux sur le net qui m'ont permit d'avancer. Mais là, j'avoue sécher sur mes recherches d'infos et j'en viens donc a poser ma question sur ce Forum.
Je cherche la ou les manières de travailler avec un tableau de valeurs du type :
2010 => 4.5,
2011 => 4.2,
2012 => 3.8,
2013 => 3.4,
2014 => 3.1
bref un tableau avec des années et leurs valeurs correspondantes, sachant que ces valeurs doivent être renseignés par l'utilisateur du programme minimaliste que je me suis donné comme objectif pour mon apprentissage.
J'ai beau fouiller google aucune piste m'a sauté aux yeux.
en PHP par exemple j'aurais fait
$tableau = array(2010=>4.5, 2011 => 4.2);
et pour ajouter une valeur à mon tableau j'aurais fait $tableau[2014] = 3.1;
En C++ je ne vois pas vraiment quel serait la procédure. Vers quoi orienter mes recherches ?
Merci pour vos éventuels conseils.

[ternel]

Il s'agit d'un dictionnaire, reliant des entrées à leur définition/valeur.
Le nom classique est map.

En C++, c'est std::map<Clé, Valeur>, si tu veux un tri sur les clés (un arbre ordonné), et std::unordered_map<Clé, Valeur> pour la table de hashage (hash table).

Dans ton cas, je prendrais str::map<int, float> ou str::map<int, double>.

Je t'invite à jeter un œil à:

• notre faq, dont la question sur les conteneurs
• la doc de map
• la doc de unordered_map

[MrBidule]

Je vais explorer ça de ce pas. Merci beaucoup d'avoir prit le temps de me répondre

[ternel]

il y a trois possibilités pratiques:
En profitant du C++11

Code c++11 :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include<map>
int main() {
    std::map<int, double> values = {
        {2010, 3.5},
        {2011, 7.4},
        {2012, 2.6},
    }
 
    //en faire quelque chose;
 
    return 0;
}

à l'ancienne: cas général

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
#include <map>
#include<utility>
int main() {
    std::map<int, double> values;
    values.insert(std::make_pair(2010, 3.5));
    values.insert(std::make_pair(2011, 7.4));
    values.insert(std::make_pair(2012, 2.6));
 
    //en faire quelque chose;
 
    return 0;
}

à l'ancienne: cas où les valeurs ont une sémantique de valeur et un constructeur par défaut. (les entiers par exemple).
Il faut bien comprendre qu'il y a des valeurs temporaires qui sont crées puis modifiées avec la valeur indiquée.
C'est potentiellement couteux, voire impossible.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
#include<map>
int main() {
    std::map<int, double> values;
    values[2010]=3.5;
    values[2011]=7.4;
    values[2012]=2.6;
 
    //en faire quelque chose;
 
    return 0;
}

edit: pas #import, mais #include, merci r0d

[r0d]

Tu es sûr pour #import?
Je ne suis pas au courant de toutes les évolutions du c++11 et c++14, mais je n'ai jamais vu ça que pour des libs (pas pour des en-têtes), et que sous Windows.

[ternel]

houla, non. C'est bien#include.

Je code en java en même temps, c'est un peu galère...

[foetus]

Mode HS

@leternel, il y a au moins 1 autre solution

Et je la donne juste pour vous faire grincer les dents
Parce qu'elle est statique (*) et niveau performances (taille tableau ou vitesse) elle doit pêcher quelque part

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
enum {
     year_1 = 2010,
     year_2
} ALL_YEARS;
 
 
int main() {
    float values[] = {
        [year_1] = 4.5f,
        [year_2] = 4.2f,
        [2012] = 3.8f,
        [2013] = 3.4f,
        [2014] = 3.1f
    };
 
    printf("%d -> %.1f\n%d -> %.1f", year_1, values[year_1], 2012, values[2012]);
 
    return 0;
}

* -> Après on peut tricher si on a un intervalle d'années pas très large, et/ ou prévoir "une roue de secours"

[ternel]

Et ca compile ca?

parce que j'ai bien pensé au Cisme suivant (index décallé):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <Type, int N>
class shiftarray{
    int shift;
    Type values[N];
public:
    explicit shiftarray(int shift) : shift(shift) {}
 
    int base() const {return shift;}
    Type& operator[](int i) {
        if (i<shift || i>=shift+N) throw std::out_of_range();
        return values[i-shift];
    }
};

[r0d]

N'oublions pas la question qui est posée, et notamment:

bref un tableau avec des années et leurs valeurs correspondantes, sachant que ces valeurs doivent être renseignés par l'utilisateur

Donc, la map ne sera pas initialisée "en dur".

[ternel]

Donc une map avec insert, ou emplace.