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.