Acest document descrie regulile standard de coding style care trebuie urmate pentru proiectele de programare orientată pe obiecte (POO) în C++.

1. Fiecare clasă trebuie definită într-un fișier separat:
   • Declarațiile clasei în fișierul de header (.h).
   • Implementările metodelor în fișierul sursă (.cpp).
2. Include-urile trebuie să fie ordonate astfel:
   • Header-ul propriu al fișierului.
   • Alte header-uri din proiect.
   • Biblioteci standard C++.
3. Exemple de structură:

  // Exemplu include-uri
  #include "MyClass.h"
  #include "Helper.h"
  #include <iostream>
  #include <vector>
  

1. Clase: PascalCase (ex. MyClass).
2. Metode: camelCase (ex. getValue()).
3. Variabile membre: camelCase cu prefix m_ (ex. m_value).
4. Constante: toate literele mari, separate prin underscore (ex. MAX_VALUE).
5. Spații de nume (namespace): lowercase (ex. namespace utils).
6. Enumerări: PascalCase pentru tipuri, toate literele mari pentru valori.

    enum class Color {
        RED,
        GREEN,
        BLUE
    };

• Indentare: 4 spații (nu tab-uri).
• Acolade: Stil Allman (acoladele deschise pe linie separată).

    class MyClass
    {
    public:
        void myMethod()
        {
            // Cod aici
        }
    };

• Lungimea liniei: maxim 80 de caractere.
• Spații:
  • Spațiu înainte și după operatori binari (ex. a + b).
  • Spațiu după virgulă (ex. func(a, b)).

• Reguli generale:
  • Inițializați toate variabilele în constructor folosind lista de inițializare.

    MyClass::MyClass(int value)
        : m_value(value)
    {
    }

• Getter și Setter:

• Getterii trebuie să fie constanți (ex. int getValue() const;).
• Metodele care nu modifică obiectul trebuie să fie declarate const.

    class MyClass
    {
    private:
        int m_value;
 
    public:
        int getValue() const { return m_value; }
        void setValue(const int& value) { m_value = value; }
    };

1. Evitați utilizarea directă a funcțiilor using namespace std;. Folosiți calificative explicite (ex. std::vector).
2. Minimizați dependențele între clase.
3. Respectați principiile SOLID pentru o arhitectură curată și extensibilă.

#include <iostream>
 
class MyClass
{
private:
    int m_value;
 
public:
    MyClass(int value)
        : m_value(value)
    {
    }
 
    int getValue() const { return m_value; }
    void setValue(int value) { m_value = value; }
};
 
int main()
{
    MyClass obj(10);
    std::cout << obj.getValue() << std::endl;
    obj.setValue(20);
    std::cout << obj.getValue() << std::endl;
 
    return 0;
}

Acest regulament va fi actualizat pe măsură ce apar cerințe suplimentare.