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ă:

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

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:
  • Folosiți public înaintea protected și protected înaintea private.
  • Inițializați toate variabilele în constructor folosind lista de inițializare.

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

• Getter și Setter:
  • Getterele trebuie să fie constante (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(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.