Popular Posts

Thursday, December 25, 2008

union, struct, and bit fields in C and C++

It took me some long time to comprehend the issues involved in using unions, structs, and bit fields in C and C++.

First, for the definition of unions and structs, take a look at this link:

Unions could be used together with structs to reinterpret the same location in memory with different interpretations (similar in spirit to the C++ reinterpret_cast). For examples on this see:

C++ extends the unions and structs, for example see:

Bit fields are used to define special-sized integers. This is useful for packing data (e.g. flags) together into one memory location. This, however, is a bad habit and should be avoided as the compiler-generated code to access bit fields is usually inefficient! For more examples on this, see:

Finally, unions and structs could be anonymous! You do not have to give a name to a union. In this case its members become directly accessible within the same scope. Wikipedia calls this "untagged union". For an example see:

Tuesday, December 23, 2008

Debugging, Profiling, Memory Leaks and more!

I have been searching for open source tools to assist in detecting memory leaks and application profiling. Also, static code analysis was another goal.

For static code analysis I found:
CppCheck (http://en.wikipedia.org/wiki/Cppcheck)

I used it to its full power by invoking (at the top level of the project):

cppcheck --recursive --all --errorsonly --style

Also, SPlint (http://en.wikipedia.org/wiki/SPlint) seems promising, though it is for C code only (no C++).

A comprehensive list of static code analysis could be found in Wikipedia:

About application profiling, the GNU Profiler (gprof) does a good job. It is light-weight and has support in GCC. This is an excellent article about using gprof:
Of course, you can best visualize the output of gprof using the (kprof) KDE front-end.

Memory leak detection has many options. Of the best is using Valgrind(http://valgrind.org/). However, I found an interesting and promising feature that has been added to the gcc. This feature is called Mudflap. It is easy to use as a compiler flag and adds memory debugging support directly into your application using libmudflap. More interesting information could be found here:
It is so promising that it will be integrated into the QNX IDE:
It can print the memory leaks on program exit via the (-print-leaks) option

Memory debugging tools are so many. There is a list on Wikipedia article:

The task of memory leak detection is achievable using lightwieght tools. These tools basically replaces the default C library malloc() and free() with special debugging implementations. Notable is mtrace(), the memory debugger built in the GNU C library:

A good article about memory leak detection in C++:

And finally, all what you can dream of are collected in one article, in the GRASS wiki here:

Hope you find this useful!