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>

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;
    vector<InfoMot*> PossibilitesIndex;

    bool operator==(InfoMot d) const
    {
        if (this->Anagramme.size() == d.Anagramme.size())
            return (this->Anagramme == d.Anagramme);
        else
            return false;
    }

    bool operator!=(InfoMot d) const
    {
        return (!(*this == d));
    }

    bool operator>(InfoMot d) const
    {
        if ((*this != d) && (d < *this))
            return  true;
        else
            return false;
    }

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

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 vector<InfoMot> TraiterMots(QString& mots)
    {
        vector<InfoMot> Mots;
        Mots.reserve(TailleMots);

        QString tempmotqs;
        tempmotqs.reserve(MaxTailleMot);

        int itempmot = 0;
        QChar lettert;

        for (int i = 0; i < mots.length(); 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.push_back(tempmot);

            tempmotqs.clear();
        }

        sort(Mots.begin(), Mots.end());
        Dictionnaire::SupprimerDoublons(Mots);

        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;
    }

    static void SupprimerDoublons(vector<InfoMot>& Mots)
    {
        std::vector<InfoMot>::iterator r, w;
        std::set<InfoMot> tmpset;

        for (r = Mots.begin(), w = Mots.begin(); r != Mots.end(); ++r)
            if (tmpset.insert(*r).second)
                *w++ = *r;

        Mots.erase(w, Mots.end());
    }
};

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

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

        for (uint i = 0; i < this->Mots.size(); i++)
        {
            //print("Numero du mot : " + QString::number((i + 1)) + " ; mot : " + ArrayToQString(this->Mots[i].Mot) + " !");

            anagrammes.push_back(this->Mots[i].Anagramme);

            this->FabriquerAnagrammes(i, anagrammes);

            this->ComparerAnagrammes(i, anagrammes);

            anagrammes.clear();
        }
    }
private:
    vector<InfoMot> Mots;

    void ComparerAnagrammes(uint i, vector<vector<int>>& anagrammes)
    {
        vector<InfoMot>::iterator it;
        InfoMot temp;
        uint index = 0;
        for (uint k = 0; k < anagrammes.size(); k++)
        {
            temp.Anagramme = anagrammes[k];
            it = std::lower_bound(this->Mots.begin(), this->Mots.end(), temp);
            if (it != this->Mots.end())
            {
                index = it - this->Mots.begin();
                if (i != index)
                    this->Mots[i].PossibilitesIndex.push_back(&this->Mots[index]);
            }
        }
    }

    void FabriquerAnagrammes(int i, vector<vector<int>>& anagrammes)
    {
        if (this->Mots[i].Anagramme.size() < MaxTailleMot)
            for (int j = 0; j < TailleAlphabet; j++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::PlusLettre, this->Mots[i].Anagramme, j));

        if (this->Mots[i].Anagramme.size() > 1)
            for (uint j = 0; j < this->Mots[i].Anagramme.size(); j++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::MoinsLetttre, this->Mots[i].Anagramme, j));

        for (uint j = 0; j < this->Mots[i].Anagramme.size(); j++)
            for (int k = 0; k < TailleAlphabet; k++)
                anagrammes.push_back(this->CreateAnagramme(TypeAnagramme::Modification, this->Mots[i].Anagramme, j, k));
    }

    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;
    }
};

static Graphe* _graphe = nullptr;

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 depart + ; + 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");
        vector<InfoMot> motstraites = Dictionnaire::TraiterMots(mots);

        _graphe = new Graphe(motstraites);

        print("Creation du graphe et des anagrammes (cette operation peut prendre quelques minutes) !");
        _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;
        delete _graphe;
    }
    catch (...)
    {
        print("ERREUR inconnue !");
        return -1;
    }
    print("\nAu revoir !");
    return 0;
}