Como fazer operador std :: vector [] compilação fazendo verificação de limites em DEBUG, mas não na liberação

Question

Estou usando o Visual Studio 2008.

Estou ciente de que std :: vector tem a verificação de limites com a função de () e tem um comportamento indefinido se você tentar acessar algo usando o operador [] de forma incorreta (fora de alcance).

Estou curioso para saber se é possível compilar meu programa com as verificação de limites. Desta forma, o operador [] usaria a função de () e jogar um std :: out_of_range sempre que algo está fora dos limites.

O modo de liberação seria compilado sem verificação de limites para o operador [], de modo que o desempenho não se degrada.

Eu vim para pensar sobre isso, porque eu estou migrando um aplicativo que foi escrito usando Borland C ++ para Visual Studio e em uma pequena parte do código que eu tenho isso (com i = 0, j = 1):

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

O tamanho do vector de 'v' é [0] [1] (0 modo elemento do vector tem apenas um elemento). Este é um comportamento indefinido, eu sei, mas Borland está retornando 0 aqui, VS está falhando. Eu gosto do acidente melhor do que retornar 0, então se eu conseguir mais 'acidentes' por exceção std :: out_of_range sendo jogado, a migração será concluída mais rápido (por isso exporia mais bugs que a Borland estava escondido).

Answer 1

Visual Studio 2005 e 2008 já fazem limites de verificação on operator[] por padrão, em ambos de depuração e compilações.

A macro para controlar este comportamento é _SECURE_SCL . Configurá-lo para 0 para desativar limites de verificação.

Seu plano atual em VS2010 é desativar limites de verificação por padrão no compilações, mas mantê-lo em na depuração. (A macro também está sendo renomeado para _ITERATOR_DEBUG_LEVEL. Eu não sei se há alguma documentação formal disponível sobre ele ainda, mas foi mencionado aqui e aqui )

Answer 2

Ativar o _GLIBCXX_DEBUG bandeira para fazer verificação de limites em contêineres STL, como discutido aqui: http://gcc.gnu.org/onlinedocs/libstdc++/manual/debug_mode.html

Answer 3

Eu perguntei isso também prematuramente, mas estou postando a resposta de qualquer maneira por isso estou compartilhando algum conhecimento.

O STL implementado em Visual Studio já fazem verificação de limites ao compilar no modo de depuração. Isso pode ser visto no cabeçalho <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));
        }

para que haja a verificação de limites para a classe vector. Eu não olhar para outros recipientes, mas estou confiante de que eles têm o mesmo mecanismo.

Answer 4

Eu não tenho acesso a qualquer máquina Windows agora. Mas se eu olhar para a implementação STL entregue com g ++ no meu mac os x máquina, a partir /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); }

Nenhuma verificação realizada, evento embora em modo de depuração. Sem marcro _GLIBCXX_DEBUG é verificada aqui neste código.

Tenha um olhar em sua própria implementação STL entregue com MSVC e ver o que é feito. Se nenhuma verificação são peformed em qualquer caso ... você não tem escolha, mas usando a () .. :-(

Answer 5

C ++ operador define vetor [] como não jogando excepção para a causa da velocidade.

Eu aconselho você a testar a aplicação na configuração de depuração por um tempo até você ganhar a confiança de que os grandes "escondidos" bugs desaparecido.