C++ - Différence de performance étrange !

#include <QCoreApplication>
#include <QString>
#include <QStringBuilder>
#include <QFile>
#include <QResource>
#include <QRegExp>
#include <QIODevice>
#include <QList>
#include <QVariant>
#include <QDataStream>
#include <QSettings>
#include <QChar>

#include <iostream>
#include <string>
#include <chrono>
#include <vector>
#include <thread>
#include <algorithm>
#include <array>
#include <set>

//faire supprimer doublon avec liste apres graphe pour sauvegarde (éventuellement)
//faire serialisation + eventuellement multithreading + optimisation suppression mots déjà 'atteints' + pour recherche anagrammes => mot. + algorithme djikstra
//peut etre bug assign auto tableau
//reoptimise inline et fastcall
//http://www.qtcentre.org/wiki/index.php?title=Profiling_with_GNU_gprof
//http://ftp.traduc.org/doc-vf/gazette-linux/html/2004/100/lg100-L.html
//http://fr.wikipedia.org/wiki/Algorithme_de_tri

using namespace std;

typedef unsigned int uint;

enum TypeAnagramme { PlusLettre, MoinsLetttre, Modification };

namespace
{
const int Alphabet[26] = { 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122 };
const int TailleMots = 336531;
const int MaxTailleMot = 25;
const int TailleAlphabet = 26;
const int TailleReserveAna = 351;

const QChar Ar = 'a';
const QString Aa = "âàä";
const QChar Er = 'e';
const QString Ea = "éèêë";
const QChar Ir = 'i';
const QString Ia = "îï";
const QChar Or = 'o';
const QString Oa = "ôö";
const QChar Ur = 'u';
const QString Ua = "ùûü";
const QChar Yr = 'y';
const QString Ya = "ÿ";

const QChar RetourLigne = '\n';

const string OptionSansTexte = "nocout";

bool AfficherLesInfos = true;
QString MotDeDepart = "";
QString MotAAtteindre = "";
}

void print(QString text, bool newline = true)
{
    if (AfficherLesInfos)
    {
        cout << text.toLatin1().constData();
        if (newline)
            cout << endl;
    }
}

QString ArrayToQString(vector<int> str)
{
    QString ret = "";
    ret.reserve(str.size());

    for (uint i = 0; i < str.size(); i++)
        ret.append((char)str[i]);

    return ret;
}

class InfoMot
{
public:
    vector<int> Mot;
    vector<int> Anagramme;

    bool operator < (InfoMot r) const
    {
        if (this->Mot.size() < r.Mot.size())
            return true;
        else if (this->Mot.size() == r.Mot.size())
        {
            if (*this == r)
                return false;
            else
            {
                for (uint i = 0; i < this->Mot.size(); i++)
                    if (this->Anagramme[i] < r.Anagramme[i])
                        return true;
                    else if (r.Anagramme[i] < this->Anagramme[i])
                        return false;
                return false;
            }
        }
        else
            return false;
    }

    bool operator ==(InfoMot r) const
    {
        return this->Anagramme == r.Anagramme;
    }
};

class Dictionnaire
{
public:
    static QString LireDictionnaire(QString dicochemin)
    {
        QFile filedico(dicochemin);
        filedico.open(QIODevice::ReadOnly);

        QByteArray bytes = filedico.readAll();

        filedico.close();
        return ((QString)bytes.constData());
    }

    static set<InfoMot> TraiterMots(QString& mots)
    {
        set<InfoMot> Mots;

        QString tempmotqs;
        tempmotqs.reserve(MaxTailleMot);

        int itempmot = 0;
        QChar lettert;

        for (int i = 0; i < TailleMots; i++)
        {
            do
            {
                if (itempmot < mots.length())
                {
                    lettert = mots.at(itempmot);
                    itempmot++;

                    DeleteAccents(Aa, Ar, lettert);
                    DeleteAccents(Ea, Er, lettert);
                    DeleteAccents(Ia, Ir, lettert);
                    DeleteAccents(Oa, Or, lettert);
                    DeleteAccents(Ua, Ur, lettert);
                    DeleteAccents(Ya, Yr, lettert);

                    tempmotqs.append(lettert);
                }
                else
                    break;
            }
            while ((itempmot < mots.length()) && (mots.at(itempmot) != RetourLigne));
            itempmot++;

            InfoMot tempmot = InfoMot();
            tempmot.Mot = QStringToAInt(tempmotqs);

            tempmot.Anagramme = tempmot.Mot;
            sort(tempmot.Anagramme.begin(), tempmot.Anagramme.end());

            Mots.insert(tempmot);

            tempmotqs.clear();
        }
        return Mots;
    }
private:
    static void DeleteAccents(const QString& acc, const QChar& remp, QChar& letter)
    {
        for (int i = 0; i < acc.size(); i++)
            if (acc.at(i) == letter)
                letter = remp;
    }

    static vector<int> QStringToAInt(QString& mot)
    {
        vector<int> valinint;
        valinint.reserve(mot.length());

        for (int i = 0; i < mot.length(); i++)
            valinint.push_back((int)(mot.at(i).toLatin1()));

        return valinint;
    }
};

class Graphe
{
public:
    Graphe(set<InfoMot>& motstraites)
    {
        this->Mots = motstraites;
        this->DeterminerIndexs();
    }

    void GenererGraphe()
    {
        vector<vector<int>> anagrammes;
        anagrammes.reserve(TailleReserveAna);

        set<InfoMot>::iterator sit (this->Mots.begin()), send(this->Mots.end());
        int i = 0;

        for (; sit != send; ++sit)
        {
            print("Numero du mot : " + QString::number((i + 1)) + " ; mot : " + ArrayToQString((*sit).Mot) + " !");

            this->Liens.push_back(vector<int>());

            this->FabriquerAnagrammesEtComparer(sit, anagrammes, i);

            anagrammes.clear();
            i++;
        }
    }
private:
    set<InfoMot> Mots;
    vector<vector<int>> Liens;
    map<int, vector<int>> Indexs;

    void DeterminerIndexs()
    {
        set<InfoMot>::iterator sit (this->Mots.begin()), send(this->Mots.end());

        int i = 0;
        uint ilength = 0;
        bool deb = true;

        for (; sit != send; ++sit)
        {
            if ((*sit).Anagramme.size() != ilength)
            {
                if (!deb)
                    Indexs[ilength].push_back(i);
                else
                    deb = false;

                ilength = (*sit).Anagramme.size();

                Indexs[ilength] = vector<int>();
                Indexs[ilength].push_back(i);
            }
            i++;
        }
    }

    void Comparer(int size, vector<vector<int>>& anagrammes, int indexp)
    {
        if (this->Indexs.find(size) != this->Indexs.end())
        {
            set<InfoMot>::iterator itp = std::next(this->Mots.begin(), this->Indexs[size][0]);
            set<InfoMot>::iterator itm = std::next(this->Mots.begin(), this->Indexs[size][1]);
            int ip = this->Indexs[size][0];

            for (; itp != itm; itp++)
            {
                if (ip != indexp)
                    for (uint i = 0; i < anagrammes.size(); i++)
                        if (anagrammes[i] == (*itp).Anagramme)
                            this->Liens[indexp].push_back(ip);

                ip++;
            }
        }
    }

    void FabriquerAnagrammesEtComparer(set<InfoMot>::iterator& sit, vector<vector<int>>& anagrammes, int indexp)
    {
        if ((*sit).Anagramme.size() < MaxTailleMot)
        {
            for (int j = 0; j < TailleAlphabet; j++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::PlusLettre, (*sit).Anagramme, j));

            this->Comparer((*sit).Anagramme.size() + 1, anagrammes, indexp);
        }
        anagrammes.clear();

        if ((*sit).Anagramme.size() > 1)
        {
            for (uint j = 0; j < (*sit).Anagramme.size(); j++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::MoinsLetttre, (*sit).Anagramme, j));

            this->Comparer((*sit).Anagramme.size() - 1, anagrammes, indexp);
        }
        anagrammes.clear();

        anagrammes.push_back((*sit).Anagramme);
        for (uint j = 0; j < (*sit).Anagramme.size(); j++)
            for (int k = 0; k < TailleAlphabet; k++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::Modification, (*sit).Anagramme, j, k));

        this->Comparer((*sit).Anagramme.size(), anagrammes, indexp);
    }

    vector<int> CreateAnagramme(TypeAnagramme type, vector<int> mot, uint j, uint k = 0)
    {
        vector<int> motmodifie = mot;

        switch (type)
        {
        case TypeAnagramme::PlusLettre:
            motmodifie.push_back(Alphabet[j]);
            break;

        case TypeAnagramme::MoinsLetttre:
            motmodifie.erase(motmodifie.begin() + j);
            break;

        case TypeAnagramme::Modification:
            motmodifie[j] = Alphabet[k];
            break;
        }

        sort(motmodifie.begin(), motmodifie.end());

        return motmodifie;
    }
};

namespace General
{
void ChargerMot(int argc, char *argv[])
{
    if (argc >= 3)
    {
        MotDeDepart = argv[1];
        MotAAtteindre = argv[2];

        if (argc == 4)
            if (((string)argv[3]) == OptionSansTexte)
                AfficherLesInfos = false;
    }
    else
    {
        print("Entrer le mot de départ + ; + le mot d'arrivé : ", false);
        string ep = "";
        cin >> ep;

        int eps = ep.find(';');
        MotDeDepart = ep.substr(0, eps).c_str();
        MotAAtteindre = ep.substr((eps + 1), ep.size()).c_str();
    }
}

void VerifierEtCreerGraphe()
{
    if (!QFile("dic.graph").exists())
    {
        print("Chargement du dictionnaire et suppression des accents !");

        QString mots = Dictionnaire::LireDictionnaire(":/motsfr/words.txt");
        set<InfoMot> motstraites = Dictionnaire::TraiterMots(mots);

        Graphe graphe = Graphe(motstraites);

        print("Creation du graphe et des anagrammes !");
        graphe.GenererGraphe();

        //TODO (faire serialisation)
    }
}
}

int main(int argc, char *argv[])
{
    print("Bonjour !\n");
    try
    {
        General::ChargerMot(argc, argv);
        print("Mot de depart : " + MotDeDepart + " ; Mot d'arrive : " + MotAAtteindre + " !\n");

        auto start = std::chrono::high_resolution_clock::now();

        General::VerifierEtCreerGraphe();

        print("Chargement du graphe ! TODO");
        //TODO (chargement du graphe sérialisé)

        print("Calcul... TODO");
        //TODO (dijkstra's algorithm)

        std::cout << "Temps : " << std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now()-start).count() << " ms !" << std::endl;
    }
    catch (...)
    {
        print("ERREUR inconnue !");
        return -1;
    }
    print("\nAu revoir !");
    return 0;
}