codingStyleGuide.org



OpenFOAM C++ style guide
#
OpenFOAM C++ style guide
General

  80 character lines max
  The body of control statements (eg, if, else, while, etc).
    always delineated with brace brackets
  stream output
    << is always four characters after the start of the stream, so that the <<
    symbols align, i.e.
    Info<<
      os  <<
  

so
WarningIn(“className::functionName()”)
  << “Warning message”
NOT
WarningIn(“className::functionName()”)
  << “Warning message”

  no unnecessary class section headers, i.e. remove
    // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
    // Check
    // Edit
    // Write
    if they contain nothing, even if planned for ‘future use’
  
  class titles are centred
    /*—————————————————————————*\
      Class exampleClass Declaration
      \*—————————————————————————*/
  

NOT
/*—————————————————————————*\
  Class exampleClass Declaration
  \*—————————————————————————*/
.H Files

  header file spacing
    Leave two empty lines between sections (as per functions in the .C file etc)
  use “//- Comment” comments in header file
    
      add descriptions to class data and functions
    
  
  destructor
    If adding a comment to the destructor - use //- and code as a normal function:
    //- Destructor
      ~className();
  
  inline functions
    Use inline functions where appropriate in a separate classNameI.H file.
    Do not clutter up the header file with function bodies

.C Files

  Do not open/close namespaces in a .C file
    Fully scope the function name, i.e.
    Foam::returnType Foam::className::functionName()
    NOT
    namespace Foam
      {
      …
    returnType className::functionName()
    …
      }
    EXCEPTION
    When there are multiple levels of namespace, they may be used in the .C
      file, i.e.
    namespace Foam
      {
      namespace compressible
      {
      namespace RASModels
      {
    …
    } // End namespace RASModels
      } // End namespace compressible
      } // End namespace Foam
  
  Use two empty lines between functions

Coding Practise

  passing data as arguments or return
    Pass label and scalar as copy, anything bigger by reference
  const
    Use everywhere it is applicable.
  variable initialisation using “=”
    const className& variableName = otherClass.data();
    NOT
    const className& variableName(otherClass.data());
  
  virtual functions
    If a class is virtual - make all derived classes virtual.

Conditional Statements
if (condition)
  {
  code;
  }
OR
if
  (
  long condition
  )
  {
  code;
  }
NOT (no space between “if” and “(“)
if(condition)
  {
  code;
  }
`for’ Loops
for (i = 0; i < maxI; i++)
  {
  code;
  }
OR
for
  (
  i = 0;
  i < maxI;
  i++
  )
  {
  code;
  }
NOT (no space between “for” and “(“)
for(i = 0; i < maxI; i++)
  {
  code;
  }
`forAll’ loops
like for loops, but
forAll(
NOT
forAll (
Splitting Over Multiple Lines

  splitting return type and function name
    
      split initially after the function return type and left align
      do not put “const” onto it’s own line - use a split to keep it with the
        function name and arguments.
    
    so:
    const Foam::longReturnTypeName&
      Foam::longClassName::longFunctionName const
    NOT
    const Foam::longReturnTypeName&
      Foam::longClassName::longFunctionName const
    NOR
    const Foam::longReturnTypeName& Foam::longClassName::longFunctionName
      const
    NOR
    const Foam::longReturnTypeName& Foam::longClassName::
      longFunctionName const
  

  if need to split again, split at the function name (leaving behind the
    preceding scoping “::“‘s), and again, left align, i.e.
    const Foam::longReturnTypeName&
      Foam::veryveryveryverylongClassName::
      veryveryveryverylongFunctionName const
  

  splitting long lines at an “=”
    Indent after split
    variableName =
      longClassName.longFunctionName(longArgument);
    OR (where necessary)
    variableName =
      longClassName.longFunctionName
      (
      longArgument1,
      longArgument2
      );
    NOT
    variableName =
      longClassName.longFunctionName(longArgument);
    NOR
    variableName = longClassName.longFunctionName
      (
      longArgument1,
      longArgument2
      );
  

Maths and Logic

  operator spacing
    
      a + b, a - b
      a*b, a/b
      a & b, a ^ b
      a = b, a != b
      a < b, a > b, a >= b, a <= b
      a || b, a && b
    
  
  splitting formulae over several lines
    Split and indent as per “splitting long lines at an “=””
    with the operator on the lower line.  Align operator so that first
    variable, function or bracket on the next line is 4 spaces indented i.e.
    variableName =
      a*(a + b)
    
      exp(c/d)
        *(k + t)
    
  
  splitting logical tests over several lines
    indent operator so that the next variable to test is aligned with the
      four space indentation, i.e.
    if
      (
      a == true
      && b == c
      )