Comment faire std :: opérateur de vecteur [] compilation faire la vérification des limites dans DEBUG, mais pas dans la version

Question

J'utilise Visual Studio 2008.

Je suis conscient que std :: vecteur a des bornes de vérification avec la fonction à () et a un comportement non défini si vous essayez d'accéder à quelque chose en utilisant l'opérateur [] de façon incorrecte (hors de portée).

Je suis curieux de savoir s'il est possible de compiler mon programme avec les limites de vérification. De cette façon, l'opérateur [] utiliserait la fonction à () et jeter un std :: out_of_range chaque fois que quelque chose est hors limites.

Le mode de libération sera compilé sans limites de contrôle pour l'opérateur [], de sorte que la performance ne se dégrade pas.

Je suis venu en pensant à cela parce que je suis la migration d'une application qui a été écrit en utilisant Borland C ++ pour Visual Studio et dans une petite partie du code que j'ai ce (avec i = 0, j = 1):

v[i][j]; //v is a std::vector<std::vector<int> >

La taille du vecteur « v » est [0] [1] (0 si l'élément du vecteur comporte un seul élément). Ce comportement est indéfini, je sais, mais Borland est de retour 0 ici, VS se bloque. J'aime le crash mieux que de retourner 0, donc si je peux obtenir plus de « accidents » par la std :: exception out_of_range étant jeté, la migration serait achevée plus rapidement (il l'exposerait plus de bugs que Borland se cachait).

Answer 1

Visual Studio 2005 et 2008 font déjà les limites de vérification sur operator[] par défaut, dans à la fois mise au point et la libération builds.

La macro pour contrôler ce comportement est _SECURE_SCL . Réglez-le à 0 pour désactiver les limites vérification.

Leur plan actuel dans VS2010 est de désactiver les limites vérification par défaut dans la version construit, mais le garder dans le débogage. (La macro est également renommé se _ITERATOR_DEBUG_LEVEL. Je ne sais pas s'il y a une documentation officielle disponible sur encore, mais il a été mentionné ici et )

Answer 2

Activer le _GLIBCXX_DEBUG de drapeau pour faire vérification des limites sur les conteneurs STL, comme indiqué ici: http://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode.html

Answer 3

J'ai demandé ce trop prématurément, mais je signale la réponse de toute façon si je partage des connaissances.

Le stl mis en œuvre dans Visual Studio font déjà des bornes de contrôle lors de la compilation en mode débogage. Cela peut être vu à l'en-tête <vector>:

reference operator[](size_type _Pos)
        {   // subscript mutable sequence

 #if _HAS_ITERATOR_DEBUGGING
        if (size() <= _Pos)
            {
            _DEBUG_ERROR("vector subscript out of range");
            _SCL_SECURE_OUT_OF_RANGE;
            }
 #endif /* _HAS_ITERATOR_DEBUGGING */
        _SCL_SECURE_VALIDATE_RANGE(_Pos < size());

        return (*(_Myfirst + _Pos));
        }

donc il y a les limites de contrôle pour la classe de vecteur. Je n'ai pas regardé d'autres conteneurs, mais je suis sûr qu'ils ont le même mécanisme.

Answer 4

Je n'ai pas accès à une machine Windows en ce moment. Mais si je regarde dans la mise en œuvre de STL livré avec g ++ sur mon mac os x machine de /usr/include/c++/4.0.0/bits/stl_vector.h:

  // element access
  /**
   *  @brief  Subscript access to the data contained in the %vector.
   *  @param n The index of the element for which data should be
   *  accessed.
   *  @return  Read/write reference to data.
   *
   *  This operator allows for easy, array-style, data access.
   *  Note that data access with this operator is unchecked and
   *  out_of_range lookups are not defined. (For checked lookups
   *  see at().)
   */
  reference
  operator[](size_type __n)
  { return *(begin() + __n); }

Aucune vérification effectuée, événement bien en mode DEBUG. Pas marcro de _GLIBCXX_DEBUG est extrait ici dans ce code.

Regardez dans votre propre implémentation de STL livré avec MSVC et voir ce qui se fait. Si aucune vérification sont peformed dans tous les cas ... vous avez pas le choix, mais en utilisant au () .. :-(

Answer 5

C ++ définit opérateur vectoriel [] ne pas jeter exception pour cause de la vitesse.

Je vous conseille de tester l'application dans la configuration de débogage pendant un certain temps jusqu'à ce que vous gagnez la confiance que les principaux bugs « cachés » disparu.