La STL Visual C ++ a-t-elle été générée par l'homme ou par du code?

Question

Je paniquer à chaque fois que j'ouvre tout STL liées au code de Visual Studio est mise en œuvre pendant le débogage de mon code:

// From <xtree>

if (_Where == begin())
    {   // insert at beginning if before first element
    if (_DEBUG_LT_PRED(this->comp,
        this->_Kfn(_Val), _Key(_Where._Mynode())))
        return (_Insert(true, _Where._Mynode(), _Val));
    }
else if (_Where == end())
    {   // insert at end if after last element
    if (_DEBUG_LT_PRED(this->comp,
        _Key(_Rmost()), this->_Kfn(_Val)))
        return (_Insert(false, _Rmost(), _Val));
    }
//...
else if (_DEBUG_LT_PRED(this->comp,
    _Key(_Where._Mynode()), this->_Kfn(_Val))
    && (++(_Next = _Where) == end()
        || _DEBUG_LT_PRED(this->comp,
            this->_Kfn(_Val), _Key(_Next._Mynode()))))
    {   // insert after _Where
    if (_Isnil(_Right(_Where._Mynode())))
        return (_Insert(false, _Where._Mynode(), _Val));
    else
        return (_Insert(true, _Next._Mynode(), _Val));
    }

La présence de commentaires me fait me sentir comme si un homme a écrit, mais la mauvaise mise en forme, l'utilisation libérale des traits de soulignement au début de tout (pourquoi?), et extrêmement illisible conditions comme (++(_Next = _Where) == end() || _DEBUG_LT_PRED ...) me faire sentir comme si ils ont été générés à partir d'un autre morceau de code source, pas écrit comme-est.

Personne ne sait qui est le cas? (Si elle a été générée à partir d'un autre morceau de code, je serais intéressé de savoir comment et pourquoi cela a été fait.)

---

Pour mémoire, voici la même chose, mais "formaté":

if (Where == begin())
{
    // insert at beginning if before first element
    if (DEBUG_LT_PRED(this->comp, this->Kfn(Val), Key(Where.Mynode())))
        return (Insert(true, Where.Mynode(), Val));
}
else if (Where == end())
{
    // insert at end if after last element
    if (DEBUG_LT_PRED(this->comp, Key(Rmost()), this->Kfn(Val)))
        return (Insert(false, Rmost(), Val));
}
//...
else if (DEBUG_LT_PRED(this->comp, Key(Where.Mynode()), this->_Kfn(Val))
    && (++(Next = Where) == end()
        || DEBUG_LT_PRED(this->comp, this->_Kfn(Val), Key(Next.Mynode()))))
{
    // insert after Where
    if (Isnil(Right(Where.Mynode())))
        return (Insert(false, Where.Mynode(), Val));
    else
        return (Insert(true, Next.Mynode(), Val));
}

À mon humble avis c' est plus comme la façon dont il s'est avéré que si un homme l'a écrit, mais encore une fois, je n'ai aucune idée.

Answer 1

Deux choses:

1. L'indentation est en fait amende, bien que de nos jours rare (et personnellement, je déteste ça): ils utilisent une mise en retrait de quatre, qui est réalisé par l'intermédiaire d'espaces, mais utilisez les onglets pour tous les multiples de huit. Cette habitude d'être la norme un peu partout (notamment, c'est le réglage par défaut de plusieurs éditeurs tels que Vim). Mais en conséquence, le code est indenté correctement si vous définissez la largeur d'un onglet à 8. Donc le code en fait ressemble à ceci:

   else if (_Where == end())
       {   // insert at end if after last element
           if (_DEBUG_LT_PRED(this->comp,
               _Key(_Rmost()), this->_Kfn(_Val)))
               return (_Insert(false, _Rmost(), _Val));
       }
   

   Qui, bien qu'encore inhabituel, est parfaitement logique et lisible.

2. C'est bien le style (ou même obligatoire?) que la bibliothèque standard utilise uniquement réservé identifiants pour éviter les collisions de noms avec des clients du code C++. Ces noms réservés sont soit des noms commençant par un caractère de soulignement suivi par une lettre majuscule (_DEBUG_LT_PRED, _Key), ou deux caractères de soulignement (pas dans ce code, mais la GCC libstdc++ est jonché __x etc.).

D'où la soupe à l'alphabet.

Mais oui, ce code est en effet écrit manuellement – au moins, il est dans le cas de la GCC. La source active de la branche de la libstdc++ ressemble exactement comme le code ci-dessus, et n'est pas auto-généré.

Answer 2

La STL fourni par VC++ est écrit par Dinkumware (et éventuellement adapté).

Pour autant que je sais, c'est écrit par des humains, mais fortement optimisée, ce qui peut laisser un goût amer dans la bouche des responsables. Il y a une raison, après tout, que l'on conseille aux débutants de ne pas micro-optimiser leur code - c'est difficile à lire. Cependant, nous nous attendons à partir d'une bibliothèque aussi essentiel que le TSL d'être largement optimisé: nous n'avons pas à maintenir de toute façon.

Je me trouve assez lisible:

• Bien échancré (ne pourrait jamais de visualiser du CCG STL correctement)
• Commenté
• Pas de gâchis, de directives de préprocesseur (ala Boost, mais évidemment il est plus facile afin de répondre aux besoins d'un seul compilateur)

Vous voudrez peut-être regarder à la libc++ pour vous convaincre que même un homme écrit de la bibliothèque, sans héritage de code (c'est frais), peut être assez compliqué. Exemple <algorithm> (l'amour de l'algorithme de tri).

Answer 3

La société d'origine du MS STL était Dinkumware . Ils avaient ce style de code horrible, et il semble être toujours là même si MS ne les utilise plus. Je suis sûr que c'est écrit à la main, probablement par la même personne, je pourrais le nommer mais je ne pense pas que je le ferai.