C++ Best Practices

Various tools are available for catching bugs and code smells in C++:

• SonarLint / SonarQube / SonarCloud: SonarLint is an IDE plugin; SonarQube/SonarCloud run in build pipelines to gate PRs.
• Clang-based tools: clang-tidy (linting), clang-check, and include-what-you-use (header management).
• Coverity Scan: Integrates with CI (Travis CI, AppVeyor) for automated analysis.
• PVS-Studio: Specialized bug detection for C/C++ and C#.
• cppclean: Focuses on problems that slow down large codebases.
• CppDepend: Visualizes code dependencies and manages design rules.
• Clang's Static Analyzer: Can be used via scan-build from CMake or through CodeChecker.
• OCLint: Open-source tool for improving code quality.
• IKOS: NASA-developed analyzer based on Abstract Interpretation.

Always initialize member variables using the member initializer list in constructors. This is more efficient for non-POD types as it avoids calling the default constructor before assignment.

For C++11 and later, you can also assign default values directly to members using {} (preferred) or =. Brace initialization {} is preferred because it prevents narrowing conversions at compile-time.

class MyClass
{
public:
  MyClass(MyOtherClass t_myOtherClass)
    : m_myOtherClass(t_myOtherClass)
  {
  }

private:
  MyOtherClass m_myOtherClass;
};

class MyClass
{
public:
  MyClass(int t_value)
    : m_value(t_value)
  {
  }

private:
  int m_value;
};

Consider integrating these tools to speed up your development workflow:

• ccache: Compile results caching for Unix-like operating systems.
• clcache: Compile results caching for cl.exe (MSVC).
• warp: Facebook's preprocessor.
• Gold Linker: If on Linux, consider using the gold linker for GCC to speed up the linking stage.

Templates can significantly increase compiled code size and build times if not used carefully. Follow these guidelines:

1. Avoid Unnecessary Template Instantiations: Instantiating many templates or templates with excessive code increases the workload on the compiler.
2. Avoid Recursive Template Instantiations: Recursive templates place a heavy load on the compiler and make code harder to maintain. Use variadic expansions and folds (C++11 and later) as an alternative.

Avoid using generic types like std::string for parameters that have specific semantic meanings (e.g., file paths, patterns, or IDs). Using generic types can lead to accidental implicit conversions and logic errors. Instead, use specific types like std::filesystem::path or std::regex.

For even higher correctness, consider using a typesafe library to prevent implicit conversions between different types that share the same underlying representation (like two different string-based IDs).

Use double quotes "" for local files and angle brackets <> for system includes. Using <> for local files requires extra compiler directives and violates standard conventions.

#include <string>    // System include
#include "MyHeader.hpp" // Local file

Avoid passing and returning simple types (like int, double, etc.) by const &. Passing and returning by reference forces pointer operations, whereas passing by value allows the compiler to use much faster processor registers. If you want to ensure a passed value is not modified, declare it as const but pass it by value.

// Good Idea
class MyClass
{
public:
  explicit MyClass(const int t_int_value)
    : m_int_value(t_int_value)
  {
  }

  int get_int_value() const
  {
    return m_int_value;
  }

private:
  int m_int_value;
};

Avoid manual memory management (new and delete) to prevent memory errors and leaks. Use C++11/C++14 smart pointers instead:

• std::unique_ptr: For exclusive ownership.
• std::shared_ptr: For reference-counted objects.
• std::make_unique (C++14) and std::make_shared: Preferred for creating smart pointers safely.

// Good Idea
auto myobj = std::make_unique<MyClass>(constructor_param1, constructor_param2); // C++14
auto myobj = std::unique_ptr<MyClass>(new MyClass(constructor_param1, constructor_param2)); // C++11
auto mybuffer = std::make_unique<char[]>(length); // C++14
auto mybuffer = std::unique_ptr<char[]>(new char[length]); // C++11

// or for reference counted objects
auto myobj = std::make_shared<MyClass>();