Come rendere std :: operator del vettore [] compilare facendo controllo dei limiti in DEBUG, ma non in RELEASE

Question

Sto usando Visual Studio 2008.

Sono consapevole che std :: vector non ha controllo dei limiti con la funzione a () e ha undefined comportamento se si tenta di accedere a qualcosa utilizzando l'operatore [] in modo non corretto (fuori campo).

Sono curioso di sapere se è possibile compilare il mio programma con i limiti controllo. In questo modo l'operatore [] avrebbe usato la funzione a () e gettare uno std :: out_of_range ogni volta che qualcosa è fuori dai limiti.

La modalità di rilascio sarebbe stato compilato senza controllo dei limiti per l'operatore [], per cui le prestazioni non si degrada.

Sono venuto a pensare su questo perché sto migrando un'applicazione che è stato scritto utilizzando Borland C ++ a Visual Studio e in una piccola parte del codice che ho questo (con i = 0, j = 1):

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

La dimensione del vettore 'v' è [0] [1] (così elemento 0 del vettore ha un solo elemento). Questo è un comportamento indefinito, lo so, ma Borland sta tornando 0 qui, VS si blocca. Mi piace l'incidente meglio di ritorno 0, quindi se posso ottenere più 'crash' da std :: eccezione out_of_range essere gettato, la migrazione si sarebbe consumato più veloce (quindi sarebbe esporre più bug che Borland era nascosto).

Answer 1

Visual Studio 2005 e il 2008 già si limiti-controllo su operator[] per impostazione predefinita, in sia debug e build di rilascio.

La macro per controllare questo comportamento è _SECURE_SCL . Impostare a 0 per disabilitare limiti controllo.

Il loro piano attuale in VS2010 è quello di disabilitare limiti controllo per impostazione predefinita in build di rilascio, ma tenerlo su di debug. (La macro è anche sempre rinominato _ITERATOR_DEBUG_LEVEL. Non so se c'è qualche documentazione formale disponibile su di esso ancora, ma è stato menzionato qui e qui )

Answer 2

Attiva il _GLIBCXX_DEBUG bandiera per fare il controllo dei limiti sui contenitori STL, come discusso qui: http://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode.html

Answer 3

Ho chiesto anche questo prematuramente, ma sto postando la risposta comunque così sto condividendo una certa conoscenza.

Lo STL implementato in Visual Studio già fare controllo dei limiti durante la compilazione in modalità debug. Questo può essere visto l'intestazione <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));
        }

per cui v'è il controllo dei limiti per la classe vettoriale. Non ho guardato in altri contenitori, ma sono fiducioso che essi hanno lo stesso meccanismo.

Answer 4

Non ho accesso a qualsiasi macchina Windows in questo momento. Ma se guardo nell'attuazione STL fornito con g ++ sul mio mac os x macchina, da /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); }

Nessun controllo eseguito, evento anche se in modalità debug. No marcro _GLIBCXX_DEBUG viene estratto qui in questo codice.

Date un'occhiata a una propria implementazione STL consegnato con MSVC e vedere ciò che viene fatto. Se nessun controllo sono peformed in ogni caso ... non hai scelta, ma usando al numero () .. :-(

Answer 5

C ++ definisce operatore vettore [] non gettare eccezione per motivi d'urgenza.

Ti consiglio di provare l'applicazione in configurazione di debug per un po 'fino a quando si guadagna la fiducia che i principali bug "nascosti" spariti.