A Little E-Book: Learn from Real Examples How to Avoid Bugs

C++

Here is a small e-Book for your attention: The Ultimate Question of Programming, Refactoring, and Everything. This book is intended for C/C++ programmers, but it could be of interest for developers using other languages as well.

What makes the book peculiar is the descriptions of real, not theoretical cases at the base of it. Each chapter starts with a code fragment taken from a real application, and then the author gives various tips of how this bug could be avoided. The questions touched upon in this book can help the readers improve the personal coding style and the coding standards used in the team.

The book covers 42 topics. In spite of the simple titles of the chapters, the bugs found are really various and non-standard. In addition to that, the text provides a lot of links to interesting materials that give more details on topics. To make more use of this book, please don’t hurry and go to the links provided.

Content:

  1. Don’t do the compiler’s job
  2. Larger than 0 does not mean 1
  3. Copy once, check twice
  4. Beware of the ?: operator and enclose it in parentheses
  5. Use available tools to analyze your code
  6. Check all the fragments where a pointer is explicitly cast to integer types
  7. Do not call the alloca() function inside loops
  8. Remember that an exception in the destructor is dangerous.
  9. Use the ‘\0’ literal for the terminal null character
  10. Avoid using multiple small #ifdef blocks
  11. Don’t try to squeeze as many operations as possible in one line
  12. When using Copy-Paste, be especially careful with the last lines
  13. Table-style formatting
  14. A good compiler and coding style aren’t always enough
  15. Start using enum class in your code, if possible
  16. «Look what I can do!» — Unacceptable in programming
  17. Use dedicated functions to clear private data
  18. The knowledge you have, working with one language isn’t always applicable to another language
  19. How to properly call one constructor from another
  20. The End-of-file (EOF) check may not be enough
  21. Check that the end-of-file character is reached correctly (EOF)
  22. Do not use #pragma warning(default:X)
  23. Evaluate the string literal length automatically
  24. Override and final identifiers should become your new friends.
  25. Do not compare ‘this’ to nullptr anymore
  26. Insidious VARIANT_BOOL
  27. Guileful BSTR strings
  28. Avoid using a macro if you can use a simple function
  29. Use a prefix increment operator (++i) in iterators instead of a postfix (i++) operator
  30. Visual C++ and wprintf() function
  31. In C and C++ arrays are not passed by value
  32. Dangerous printf
  33. Never dereference null pointers
  34. Undefined behavior is closer than you think
  35. Adding a new constant to enum don’t forget to correct switch operators
  36. If something strange is happening to your PC, check its memory.
  37. Beware of the ‘continue’ operator inside do {…} while (…)
  38. Use nullptr instead of NULL from now on
  39. Why incorrect code works
  40. Start using static code analysis
  41. Avoid adding a new library to the project.
  42. Don’t use function names with «empty»

For those, who find reading PDF format more convenient: https://yadi.sk/i/pBZqebxsr5Wyg

However, it should be borne in mind that we continue improving this article, making small edits in the text, so thew PDF version can become slightly outdated over the course of time. In case you want to share it with your colleagues, it’s better to use the link to this html-page http://www.viva64.com/en/b/0391/ that gets constantly updated.

Comments

1,128

Ropes — Fast Strings

Most of us work with strings one way or another. There’s no way to avoid them — when writing code, you’re doomed to concatinate strings every day, split them into parts and access certain characters by index. We are used to the fact that strings are fixed-length arrays of characters, which leads to certain limitations when working with them. For instance, we cannot quickly concatenate two strings. To do this, we will at first need to allocate the required amount of memory, and then copy there the data from the concatenated strings.