main.cpp

#include <map>
#include <iostream>
#include <cstring>
#include <stdio.h>

using std::map;
using std::cout;
using std::cin;
using std::endl;

struct command_comparator {
    bool operator()(const char *cmd1, const char *cmd2) const {
        return strcmp(cmd1, cmd2) < 0;
    }
};

const char *bool_str(bool b)
{
    if (b)
        return "true";
    else
        return "false";
    //return (b == 0) : "false" ? "true";
}

int main(int argc, char** argv)
{
    /*
     * Évite l'avertissement: -Wunused-parameter.
     * Ça dit au compitaleur: hey, je fais rien
     * avec cette variable et je sais ce que je fais,
     * donc laisse moi tranquille.
     */
    (void) argc;
    (void) argv;

    int command;
    char str[80];


    /*
     * Le principal problème est que la clé
     * est comparée par pointeur (adresse) par
     * défaut, et non par le contenu (ici une
     * chaine de caractère). On pourrait vouloir
     * comparer des chaines de différente manière
     * (ex: longeur, toute en minuscule, etc.). Il faut
     * donc ajouter un objet dont la fonction est
     * d'indiquer comment comparer deux éléments.
     */
    map<const char*, int, command_comparator> commands;
    map<const char*, int>::iterator it;

    /* Pourquoi 80 octets? Il vaut mieux laisser
     * le compilateur réserver la taille nécessaire
     * automatiquement. Ici, les commandes ne changent
     * pas (constantes).
     */

//    char a[80] = "exit"; // Simplement écrire  'commands["exit"] = 0;'  me donne un warning.
//    char b[80] = "+";
//    char c[80] = "-";
//    char d[80] = "sci";


    const char *a = "exit";
    const char *b = "+";
    const char *c = "-";
    const char *d = "sci";

    commands[a] = 0;
    commands[b] = 1;
    commands[c] = 2;
    commands[d] = 3;

    do {
        /* En théorie, donner en input la commande 'exit'
         * devrait sortir de la boucle pusique c'est la
         * clée de 0 dans le map 'commands'.
         *
         * Pourtant, quand j'exécute mon programme, je reçois:
         * exit 1573148360 <- Ceci devrait être la valeure de la clée 'exit'
         * dans le map 'commands', soit 0.
         *
         * commands[sci] = 3
         * sci = exit: 0 <- Le 0 est le résultat de la
         * comparaison entre la clée et la commande.
         * sci != exit, donc 0 fait du sens.
         *
         * commands[-] = 2
         * - = exit: 0
         *
         * commands[+] = 1
         * + = exit: 0
         *
         * commands[exit] = 0
         * exit = exit: 0 <- ??? La comparaison entre
         * 'exit' et 'exit' devrait donner 'true'  donc 1.
         *
         * Est-ce un problème de type? Pourtant j'ai l'impression
         * que je compare bien un char[80] et un char[80]...
         */

        cout << "--> ";
        cin >> str;
        cout << std::endl;

        it = commands.find(str);

        command = it->second;

        cout << str << " " << command << endl;

        /* tester si la clé n'est pas trouvée */
        if (it == commands.end()) {
            cout << "command not found" << endl;
            continue;
        }

        for (map<const char*, int>::iterator i = commands.begin(); i != commands.end(); i++) {
            bool comparaison_address = i->first == str;
            /* ici, on compare l'adresse, plutôt que le contenu. */
            bool comparaison_contenu = strcmp(i->first, str) == 0;

            printf("%s@(%p) %s@(%p) eq_addr=%s eq_str=%s\n", str, str,
                   i->first, i->first, bool_str(comparaison_address), bool_str(comparaison_contenu));
        };

    } while (command);
}