A program that uses the C++ standard library correctly
  will maintain the same semantics under debug mode as it had with
  the normal (release) library. All functional and exception-handling
  guarantees made by the normal library also hold for the debug mode
  library, with one exception: performance guarantees made by the
  normal library may not hold in the debug mode library. For
  instance, erasing an element in a std::list is a
  constant-time operation in normal library, but in debug mode it is
  linear in the number of iterators that reference that particular
  list. So while your (correct) program won't change its results, it
  is likely to execute more slowly.
libstdc++ includes many extensions to the C++ standard library. In
  some cases the extensions are obvious, such as the hashed
  associative containers, whereas other extensions give predictable
  results to behavior that would otherwise be undefined, such as
  throwing an exception when a std::basic_string is
  constructed from a NULL character pointer. This latter category also
  includes implementation-defined and unspecified semantics, such as
  the growth rate of a vector. Use of these extensions is not
  considered incorrect, so code that relies on them will not be
  rejected by debug mode. However, use of these extensions may affect
  the portability of code to other implementations of the C++ standard
  library, and is therefore somewhat hazardous. For this reason, the
  libstdc++ debug mode offers a "pedantic" mode (similar to
  GCC's -pedantic compiler flag) that attempts to emulate
  the semantics guaranteed by the C++ standard. For
  instance, constructing a std::basic_string with a NULL
  character pointer would result in an exception under normal mode or
  non-pedantic debug mode (this is a libstdc++ extension), whereas
  under pedantic debug mode libstdc++ would signal an error. To enable
  the pedantic debug mode, compile your program with
  both -D_GLIBCXX_DEBUG
  and -D_GLIBCXX_DEBUG_PEDANTIC .
  (N.B. In GCC 3.4.x and 4.0.0, due to a bug,
  -D_GLIBXX_DEBUG_PEDANTIC was also needed. The problem has
  been fixed in GCC 4.0.1 and later versions.) 
The following library components provide extra debugging capabilities in debug mode:
std::array (no safe iterators)
std::basic_string (no safe iterators and see note below)
std::bitset
std::deque
std::list
std::map
std::multimap
std::multiset
std::set
std::vector
std::unordered_map
std::unordered_multimap
std::unordered_set
std::unordered_multiset
N.B. although there are precondition checks for some string operations,
e.g.  operator[],
they will not always be run when using the char and
wchar_t specializations (std::string and
std::wstring).  This is because libstdc++ uses GCC's
extern template extension to provide explicit instantiations
of std::string and std::wstring, and those
explicit instantiations don't include the debug-mode checks.  If the
containing functions are inlined then the checks will run, so compiling
with -O1 might be enough to enable them.  Alternatively
-D_GLIBCXX_EXTERN_TEMPLATE=0 will suppress the declarations
of the explicit instantiations and cause the functions to be instantiated
with the debug-mode checks included, but this is unsupported and not
guaranteed to work.  For full debug-mode support you can use the
__gnu_debug::basic_string debugging container directly,
which always works correctly.