Mir C++ Style Guide

Hooray! Now you know you can expand points to get more details. Alternatively, there's an "expand all" at the top of this document.

To guarantee uniqueness, they should be based on the full path in a project's source tree. For example, the file foo/src/bar/baz.h in project foo should have the following guard:

#ifndef FOO_BAR_BAZ_H_
#define FOO_BAR_BAZ_H_

...

#endif  // FOO_BAR_BAZ_H_

When you include a header file you introduce a dependency that will cause your code to be recompiled whenever the header file changes. If your header file includes other header files, any change to those files will cause any code that includes your header to be recompiled. Therefore, we prefer to minimize includes, particularly includes of header files in other header files.

You can significantly reduce the number of header files you need to include in your own header files by using forward declarations. For example, if your header file uses the File class in ways that do not require access to the declaration of the File class, your header file can just forward declare class File; instead of having to #include "file/base/file.h".

How can we use a class Foo in a header file without access to its definition?

• We can declare data members of type Foo* or Foo&.
• We can declare (but not define) functions with arguments, and/or return values, of type Foo. (One exception is if an argument Foo or Foo const& has a non-explicit, one-argument constructor, in which case we need the full definition to support automatic type conversion.)
• We can declare static data members of type Foo. This is because static data members are defined outside the class definition.

On the other hand, you must include the header file for Foo if your class subclasses Foo or has a data member of type Foo.

Sometimes it makes sense to have pointer (or better, unique_ptr) members instead of object members. However, this complicates code readability and imposes a performance penalty, so avoid doing this transformation if the only purpose is to minimize includes in header files.

Of course, .cpp files typically do require the definitions of the classes they use, and usually have to include several header files.

Note: If you use a symbol Foo in your source file, you should bring in a definition for Foo yourself, either via an #include or via a forward declaration. Do not depend on the symbol being brought in transitively via headers not directly included. One exception is if Foo is used in myfile.cpp, it's ok to #include (or forward-declare) Foo in myfile.h, instead of myfile.cpp.

Definition: You can declare functions in a way that allows the compiler to expand them inline rather than calling them through the usual function call mechanism.

Pros: Inlining a function can generate more efficient object code, as long as the inlined function is small. Feel free to inline accessors and mutators, and other short, performance-critical functions.

Cons: Overuse of inlining can actually make programs slower. Depending on a function's size, inlining it can cause the code size to increase or decrease. Inlining a very small accessor function will usually decrease code size while inlining a very large function can dramatically increase code size. On modern processors smaller code usually runs faster due to better use of the instruction cache.

Decision:

A decent rule of thumb is to not inline a function if it is more than 10 lines long. Beware of destructors, which are often longer than they appear because of implicit member- and base-destructor calls!

Another useful rule of thumb: it's typically not cost effective to inline functions with loops or switch statements (unless, in the common case, the loop or switch statement is never executed).

It is important to know that functions are not always inlined even if they are declared as such; for example, virtual and recursive functions are not normally inlined. Usually recursive functions should not be inline. The main reason for making a virtual function inline is to place its definition in the class, either for convenience or to document its behavior, e.g., for accessors and mutators.

The definition of an inline function needs to be in a header file, so that the compiler has the definition available for inlining at the call sites. However, implementation code properly belongs in .cpp files, and we do not like to have much actual code in .h files unless there is a readability or performance advantage.

If an inline function definition is short, with very little, if any, logic in it, you should put the code in your .h file. For example, accessors and mutators should certainly be inside a class definition. More complex inline functions may also be put in a .h file for the convenience of the implementer and callers, though if this makes the .h file too unwieldy you can instead put that code in a separate -inl.h file. This separates the implementation from the class definition, while still allowing the implementation to be included where necessary.

Another use of -inl.h files is for definitions of function templates. This can be used to keep your template definitions easy to read.

Do not forget that a -inl.h file requires a #define guard just like any other header file.

Parameters to C/C++ functions are either input to the function, output from the function, or both. Input parameters are usually values or const references, while output and input/output parameters will be non-const references or pointers to non-const. When ordering function parameters, put all output parameters before any input-only parameters. In particular, do not add new parameters to the end of the function just because they are new; place new output parameters before the input-only parameters.

This is not a hard-and-fast rule. Parameters that are both input and output (often classes/structs) muddy the waters, and, as always, consistency with related functions may require you to bend the rule.

All of a project's header files should be listed as descendants of the project's source directory without use of UNIX directory shortcuts . (the current directory) or .. (the parent directory). For example, my-awesome-project/src/base/logging.h should be included as

#include "base/logging.h"

In dir/foo.cpp or dir/foo_test.cpp, whose main purpose is to implement or test the stuff in dir2/foo2.h, order your includes as follows:

1. dir2/foo2.h (preferred location — see details below).
2. Your project's public .h files.
3. Your project's private .h files.
4. Other libraries' .h files.
5. C system files.
6. C++ system files.

The preferred ordering reduces hidden dependencies. We want every header file to be compilable on its own. The easiest way to achieve this is to make sure that every one of them is the first .h file #included in some .cpp.

dir/foo.cpp and dir2/foo2.h are often in the same directory (e.g. base/test_basictypes.cpp and base/basictypes.h), but can be in different directories too.

Within each section it is nice to order the includes alphabetically.

For example, the includes in my-awesome-project/src/foo/internal/fooserver.cpp might look like this:

        #include "foo/public/fooserver.h"  // Preferred location.

	#include "base/basictypes.h"
        #include "base/commandlineflags.h"
        #include "foo/public/bar.h"

        #include <sys/types.h>
        #include <unistd.h>

        #include <hash_map>
        #include <vector>

Definition: Namespaces subdivide the global scope into distinct, named scopes, and so are useful for preventing name collisions in the global scope.

Pros:

Namespaces provide a (hierarchical) axis of naming, in addition to the (also hierarchical) name axis provided by classes.

For example, if two different projects have a class Foo in the global scope, these symbols may collide at compile time or at runtime. If each project places their code in a namespace, project1::Foo and project2::Foo are now distinct symbols that do not collide.

Cons:

Namespaces can be confusing, because they provide an additional (hierarchical) axis of naming, in addition to the (also hierarchical) name axis provided by classes.

Use of unnamed spaces in header files can easily cause violations of the C++ One Definition Rule (ODR).

Decision:

Use namespaces according to the policy described below.

Unnamed Namespaces

• Unnamed namespaces are allowed and even encouraged in .cpp files, to avoid runtime naming conflicts:

  namespace                           // This is in a .cpp file.
  {
  // The content of a namespace is not indented
  enum { UNUSED, EOF, ERROR };       // Commonly used tokens.
  bool AtEof() { return pos_ == EOF; }  // Uses our namespace's EOF.
  
  }  // namespace

  However, file-scope declarations that are associated with a particular class may be declared in that class as types, static data members or static member functions rather than as members of an unnamed namespace. Terminate the unnamed namespace as shown, with a comment // namespace.

• Do not use unnamed namespaces in .h files.

Named Namespaces

Named namespaces should be used as follows:

• Namespaces wrap the entire source file after includes, gflags definitions/declarations, and forward declarations of classes from other namespaces:

  // In the .h file
  namespace mynamespace
  {
  
  // All declarations are within the namespace scope.
  // Notice the lack of indentation.
  class MyClass
  {
  public:
      ...
      void foo();
  };
  
  }  // namespace mynamespace

  // In the .cpp file
  namespace mynamespace
  {
  
  // Definition of functions is within scope of the namespace.
  void MyClass::foo()
  {
      ...
  }
  
  }  // namespace mynamespace

  The typical .cpp file might have more complex detail, including the need to reference classes in other namespaces.

  #include "a.h"
  
  DEFINE_BOOL(someflag, false, "dummy flag");
  
  class C;  // Forward declaration of class C in the global namespace.
  namespace a { class A; }  // Forward declaration of a::A.
  
  namespace b
  {
  
  ...code for b...         // Code goes against the left margin.
  
  }  // namespace b

• Do not declare anything in namespace std, not even forward declarations of standard library classes. Declaring entities in namespace std is undefined behavior, i.e., not portable. To declare entities from the standard library, include the appropriate header file.
• You may use a using-directive to make all names from a namespace available, but only in a source file.
• You may use a using-declaration anywhere in a .cpp file, and in functions, methods or classes in .h files.

  // OK in .cpp files.
  // Must be in a function, method or class in .h files.
  using ::foo::bar;

• Namespace aliases are allowed anywhere in a .cpp file, anywhere inside the named namespace that wraps an entire .h file, and in functions and methods.

  // Shorten access to some commonly used names in .cpp files.
  namespace fbz = ::foo::bar::baz;
  
  // Shorten access to some commonly used names (in a .h file).
  namespace librarian
  {
  // The following alias is available to all files including
  // this header (in namespace librarian):
  // alias names should therefore be chosen consistently
  // within a project.
  namespace pd_s = ::pipeline_diagnostics::sidetable;
  
  inline void my_inline_function()
  {
      // namespace alias local to a function (or method).
      namespace fbz = ::foo::bar::baz;
      ...
  }
  }  // namespace librarian

  Note that an alias in a .h file is visible to everyone #including that file, so public headers (those available outside a project) and headers transitively #included by them, should avoid defining aliases, as part of the general goal of keeping public APIs as small as possible.

Definition: A class can define another class within it; this is also called a member class.