C/C++

• Forgetting a semicolon at the end of the line. Can cause various strange compile errors.

• Putting a semicolon after the function header of the implementation of a function:

  void foo();
  {
      cout << "foo" << endl;
  }
  

  This will result in an error like test.cc:2: parse error before `{'.

• Forgetting to terminate a string constant, for example

  void foo()
  {
      cout << "hello world! << endl;
  }
  

  This will result in an error like

  string.cc:5: unterminated string or character constant
  string.cc:5: possible real start of unterminated constant
  

• No ; at the end of an enum/union/struct definition. Can result in lots of compile errors.

• Entering too many or too few (, ), { or }. This will also produce lots of compiler errors. A possible solution is using an editor with the ability to match () and {}, like vi and emacs.

• Recursive including of .h files. Will generate an error like
  header.h:1: macro or `#include' recursion too deep.
  Solution: put the contents of each header file between a #ifndef command, like
  
  #ifndef _filename_H_
#define _filename_H_
  :
  contents of .h file
  :
  #endif

• Including a header file multiple times. This can sometimes lead to warnings or errors. Solution: same as with recursive including.

• Defining functions without an explicit return type. Functions and variables that are declared without a type default to int, not to void.

• Defining functions and implementing them with some other return type. For example defining a function in a header file like this:

      int the_answer();
  

  and implementing it like this:

      unsigned int the_answer()
      {
          return 42;
      }
  

  This will result in an error like:

  return.c:10: conflicting types for `the_answer'
  return.c:5: previous declaration of `the_answer'
  

  The solution is to make the two return types the same.