coding conventions

naming:

• types in camelCase (capital letter)
• functions, variables in camelCase
• namespaces lower case
• Macros UPPERCASE
• protected or private member variables have prefix m_
• (function parameters start with _)
• file endings: ".cpp" and ".hpp"

structure:

• use a decent amount of spaces
• braces for scopes generally in a new line
• use sensible namespaces, usually corresponding to the file structure
• function definitions in source files, one-liners (get,set,...) can be inline
• use const where applicable (especially for parameters(const&) and functions!)
• if possible use predeclarations instead of #include in headers to keep compile times low
• tabs for indentation
• in-class initialization for members

example:

// ClassName.hpp
#pragma once

// -- own includes
#include "MyClass.hpp"

// -- lib includes
#include <lib/Header.hpp>

// -- std includes
#include <vector>

#define DEBUG_INFO __LINE__
constexpr int SIZE = 10; 

namespace example {

  template<typename U, typename T>
  concept ForwardingType = std::is_same_v<T, std::remove_cvref_t<U>>;

  template<typename T>
  class ClassName 
  {
  public:
      ClassName()                              = default;
      ClassName( const ClassName& )            = delete;
      ClassName& operator=( const ClassName& ) = delete;
      ClassName( ClassName&& )                 = default;
      ClassName& operator=( ClassName&& )      = default;
    
      //ClassName( const T& _value );
    
      template<ForwardingType<T> U>
      ClassName( U&& _value );
    
      /*
       * @brief description.
       * @param argument argument descritpion.
       */
      void publicFunction( const T& _argument );

      /*
       * @brief function with an very long signature.
       * @param _arg1 pointer to vector of class 
       * @param _arg2 description missing
       */
      void longSignatureFunction(
          const std::shared_ptr<std::vector<MyClass>>& _arg1,
          const std::shared_ptr<OtherClass>& _arg2 );

      const T& getField() const { return m_field; }

      int getNumber() const { return m_number; }

      int getArray(int i) static { return s_array[i]; }      

  private:
      void PrivateFunction();

      T m_field {};
      int m_number {0};

      static constexpr std::array<int, 3> s_array = {1, 2, 3};
  };

  template<typename T>
  template<ForwardingType<T> U>
  ClassName<T>::ClassName( U&& _value )
   : m_field{ std::forward<U>( _value ) } 
  {}

  template<typename T>
  void ClassName<T>::PublicFunction( const T& _argument ) 
  {
    …
  }
} // end example