C++ Coding Guidelines

Notes:

C++ version used should be c++17

Naming

1. Class, enums and global functions name must be PascalCase
2. Method identifiers should be camelCase
3. Variables identifiers should be snake_case
4. Constants and constexpr identifiers (global or not) must start with “k_” and use snake_case (like k_buffer_size)
5. Attributes of a class must start with “_” symbol
6. Macros, if used, must use SNAKE_CASE (all uppercase)
7. File names .hpp and .cpp should be snake_case
8. Both names .hpp and .cpp should be equal (obviously changing the file extension)

Namespaces

1. Required only on the main software repository for IFAE commons

2. It’s recommended for each project the use of namespaces (following common sense criteria) but declaration and organization is set by each project.

3. Identifiers:

   • Not too general and not too specific
   • Maximum namespace levels after
   • Always use lower case
   • No use of Acronyms (Unique valid case is ifae and or projects namespace identifier)

   Bad:

    IFAE::cta::tools // IFAE should be lowercase 
    ifae::CTA::tools // CTA should be lowercase
    ifae::cta::Tools // All namespace should be lowercase

   Good:

    ifae::cta::tools

4. Anonymous namespaces:

Anonymous namespaces can be used, and it’s use is specially valid as an alternative to a static variable declaration

Files

1. Both files (hpp and cpp) should be in the same folder

Classes

1. Preferably Each “exportable” class shall have its own header and implementation file. Supporting classes with implementation details should be hidden, using an anonymous namespace and not being declared in include file

2. Classes element order:

	class TestClassA{
	  public:
	    // methods: (First constructors and destructors)
	  protected:
	    // methods
	    // attributes
	  private: 
	    // methods
	    
	    // attributes initialized by the constructor
	    
	    // attributes default initialized
	    
	    // attributes manually initialized
	    
	    //friend declarations
	}

1. If one of the next constructors are declared, other five should be also declared (rule of five). “default” and “delete” operators can be used if needed #### Example: ##### hpp: information.hpp

	class Information{
	    public:
	    Information() = default;
	    ~Information() = default;
	    
	    Information(const Information& information) = default;
	    Information(Information&& information) = default;
	
	    Information& operator=(const Information& information) = delete;
	    Information& operator=(Information&& information) = delete;
	};

1. If constructors, copy constructors and copy operators are all defaulted, neither of them should be declared (rule of zero).

2. If a class is not designed to be inherited must be marked as final

Enums

Includes

1. First include STL headers. Then third party libraries and finally header files of the cpp object.

2. Includes in a file should be sorted alphabetically

3. Avoid non needed includes, it makes modules more dependant and compilation slower. Prefer forward declaration than including a full include if able.

4. #pragma once directive: To avoid multiple including of a file use #pragma once instead of the old fashion #ifdef #endif

   Correct:

   ##### line.hpp

    #pragma once 
   
    #include "linetype.hpp" //needed include
    class Point; // Forward declaration
    class Line {
        public:
        Line(const Point& point_a, const Point& point_b);
        ~Line() = default;
   
        Line(const Line& line);
        Line(Line&& line);
        Line& operator=(const Line& line);
        Line& operator=(Line&& line);
   
        private:
        LineType line_type;
    }; 

   ##### line.cpp

	#include "line.hpp" //first include is reference .hpp
	
	#include "linetype.hpp" //Alphabetically ordered
	#include "point.hpp"
	
	Line::Line(const Point& point_a, const Point& point_b) {...}