As you know, the C++ language assumes that the programmer is always correct. Therefore C++ compilers don't add additional checks to the program, such as checks for null pointer dereference or out-of-bounds array access. This is good, because C++ programs run as fast as possible, and this is bad, because sometimes we may spend a long time debugging some silly mistake. We would want that the compiler can find such mistakes automatically. And many compilers can! In this post I will show various GCC options that do this. Previously zakharvoit already wrote about this here.

All options that will follow should be added to the GCC command line. In various IDEs you can do it in IDE or compiler settings. Many of the options can also be used with Clang (for example, in Xcode). For MSVC++, I think, there is nothing better than Debug mode and /W4.  

GCC warnings

Of course, the first step to debugging is to enable compiler warnings. Even this alone often helps. As a bare minimum I should name -Wall -Wextra -O2. The last option is needed because some warnings are only enabled together with optimization. Below I will list some useful options that are not enabled with -Wall -Wextra.

• -pedantic — warns about non-standard C++ language extensions. This way you can eliminate stuff that might not be supported by the testing server, and save time needed to rewrite the code. This is best used together with -std=c++03 or -std=c++11. For example, -pedantic -std=c++03 will warn about

printf("%lf\n", 1.0);

— the correct way is

printf("%f\n", 1.0);

• -Wshadow — warns if a declared name shadows the same name in some outer level. For example, this will cause a warning:

int n;
void solve()
{
    // Solve the problem
}
int main()
{
    int n; cin >> n;
    solve();
}

• -Wformat=2 — warns if an argument type in printf()/scanf() does not correspond to the format string. This is partially enabled by -Wall, but -Wformat=2 is more strict.

• -Wfloat-equal — warns if two floating point values are compared directly: a == b. Usually the correct way is: fabs(a - b) < eps.

• -Wconversion — warns if data can be lost in an implicit conversion.¹ Most often it is accidental assignment of a long long value to an int variable. I have this warning enabled since I failed a problem by writing pair<int, int> instead of pair<int, long long> :)
  
  ¹ An explicit cast (for example, (double)my_long_long_var) will not trigger this warning.

• -Wlogical-op — warns about logical operators in places where GCC expects bitwise operators.

• -Wshift-overflow=2 — warns about left shift overflows (GCC 6+).

• -Wduplicated-cond — warns about repeated conditions in if (…) else if (…) (GCC 6+).

There are also -Wcast-qual и -Wcast-align, but they are less useful (though don't hurt). You can read more about GCC warnings here: https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html

Standard library tools

Besides the compiler itself, there is also the standard C/C++ library. It also has some options that aid debugging.

• -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC — these options turn on a special debug mode in the GNU C++ standard library. In this mode standard containers and algorithms apply various checks. For example, this code

int main()
{
    vector<int> v(3);
    cout << v[7] << endl;
}

prints

 /usr/include/c++/4.9.2/debug/vector:357:error: attempt to subscript 
  container with out-of-bounds index 7, but container only holds 3 
  elements. 

And this code:

int main()
{
    int arr[] = { 3, 1, 2 };
    cout << binary_search(arr, arr+3, 2) << endl;
}

prints

 /usr/include/c++/4.9.2/bits/stl_algo.h:2267:error: elements in iterator
  range [__first, __last) are not partitioned by the value __val. 

• -D_FORTIFY_SOURCE=2 (only on Linux/glibc) — this option inserts security checks, such as checks for buffer overflows, into the program. For example, this program:

int main()
{
    char s[9];
    strcpy(s, "too large");
    cout << s << endl;
}

when compiled with this option, prints

 *** buffer overflow detected ***: ./a.out terminated 

GCC tools

The GCC compiler also contains tools that help find mistakes in programs.

• -fsanitize=address (only in GCC 4.8+ and Clang) — this option inserts memory access checks into the program, such as checks for out-of-bounds accesses. This program:

int arr[3];

int main()
{
    for (int i = 0; i <= 3; i++)
    {
        arr[i] = i;
        cout << arr[i] << " ";
    }
    cout << endl;
}

prints

 =================================================================
 ==15496==ERROR: AddressSanitizer: global-buffer-overflow on address 0x00000060152c at pc 0x400ad4 bp 0x7fffbac43e00 sp 0x7fffbac43df0
 WRITE of size 4 at 0x00000060152c thread T0
 . . . 

• -fsanitize=undefined -fno-sanitize-recover (only in GCC 4.9+ and Clang) — a similar option that catches undefined behavior, for example, a null pointer dereference. This code:

int main()
{
    int *p;
    cout << *p << endl;
}

prints

 x.cpp:12:14: runtime error: load of null pointer of type 'int' 

-fsanitize=undefined can also find divisions by zero, undefined integer shifts, signed integer overflows and leaving a function without a return value.

These two options are described in https://gcc.gnu.org/onlinedocs/gcc/Debugging-Options.html. There is also the -fstack-protector option.

Everything together

Putting everything together, we get

-Wall -Wextra -pedantic -std=c++11 -O2 -Wshadow -Wformat=2 -Wfloat-equal -Wconversion -Wlogical-op -Wshift-overflow=2 -Wduplicated-cond -Wcast-qual -Wcast-align -D_GLIBCXX_DEBUG -D_GLIBCXX_DEBUG_PEDANTIC -D_FORTIFY_SOURCE=2 -fsanitize=address -fsanitize=undefined -fno-sanitize-recover -fstack-protector

All this (or selected parts) can be added to GCC command line on the local computer. Therefore, we run a debug-enabled version on our computer, and the usual version on the server. Naturally, the local debug version will be slower — the biggest impact is from the -fsanitize options (can cause 2× and more slowdown). But you can easily account for this, and it is a small price to pay. Depending on the compiler version and operating system, not every option from this list will work — just take such options out.

I hope that this post will help people spend less time debugging and more time solving problems. Good luck :)

UPD1: There is a problem with -D_GLIBCXX_DEBUG, but a workaround is known. (If string s; cin >> s; fails for you, try removing -fwhole-program from the command line or adding s.reserve(...); in the code).

UPD2: Updated options:

• Added -fno-sanitize-recover (GCC 5+)
• Removed -lmcheck (replaced by -fsanitize=address)
• Removed -ftrapv (replaced by -fsanitize=undefined)
• Removed -fwhole-program (unstable and is not a debug option)

UPD3: Added -Wshift-overflow=2 and -Wduplicated-cond (GCC 6+).