Stilul Codului

Stil acolade

Se foloseste stilul de acolade C++

functie (void)
{
   block de cod
}

Nu se lasa spatiu intre tipul de data si parametrii template. Ex:

• ASA std::vector<int>
• NU ASA std::vector <int>

Spatiere

• SE LASA spatiu dupa operatori si instructiuni.
• NU SE LASA spatiu dupa si inaintea paranetezelor. Ex:

if(functie_care_returneaza_ceva(2, 3, 4) == 2)

###Conventii pt. denumirea tipurilor de date:

• Tipuri de date. Se foloseste CamelCase

class TipDeData;
using IntPair = std::pair<int, int>;

• Variabile. Minuscule cu underscore intre cuvinte

int variabila_cu_nume_lung;

• Functii si metode. Minuscule cu underscore intre cuvinte, cu primul dintre ele verb.

void fa_ceva_actiune(void);

###Aliniere si indentare instructiuni.

• Se incepe pe rand nou cu indentare dupa while, for si if. Exceptie se poate face la if daca e o singura instructiune.
• else if se scrie legat.
• Nu sunt necesare acoladele cand blocul de cod contine o singura instructiune.

if(conditie1) return o_pula;
else if(conditie2)
    return alta_pula;
while(conditie de repetare)
{
   // bloc de instructiuni   
}

Daca o expresie se extinde pe mai multe linii, linile urmatoare incep cu operatorul saliniat la un spatiu dupa parantea careia ii sunt subordonati.

if ((!(ep < NUM_POINTS && ep >= 0) && all_in_house)                                                              // (daca punctul de aterizare nu e in intervalul 0, 23 SI se poate scoate)
    || ((ep < NUM_POINTS && ep >= 0) && ((board.points[ep].color != player && board.points[ep].number < 2)       // SAU (e in interval SI ((sunt mai putin de 2 piese de culoare opusa)
                                         || board.points[ep].color == player)))                                  //                        SAU (se aterizeaza pe aceasi culoare))),

###Comentarii.

• Orice tip de data sau metoda/functie trebuie documentata(comentata) Ex.

    class HelperBoard 
    {
    private:
        BoardState current_board_state; // asta se initializeaza din bagamon. dupa se modifica cand se fac mutari
        Color player; // playeru care face mutaorile
        DicePair dices; // zarurile cu care se lucreaza
        Turn history;   // se pusheaza aici toate mutarile ( first = poz.init, second = nr mutari )
        std::multiset<int> remaining_moves; // mutarile ramase cu care se lucreaza

        const std::set <Turn> *valid_moves; // pointer catre mutarile valide din Round

    public:
        // clasa pe care poti face mutari, da undo, verifica legalitatea lor etc
        HelperBoard(void);
        HelperBoard(const Round&); // initializeaza o tabla temporara din clasa de joc
        HelperBoard(const HelperBoard&); // constructor copiere
        HelperBoard& operator=(HelperBoard); // operator copiere

        void init_from_board(const Round&);

        BoardState get_board_state(void) const;
        Turn get_turn(void) const; // returneaza mutarile de pana acuma
        void push_move(CheckerMove); // face o mutare. daca ilegala, arunca exceptie
        void pop_move(void); // da undo la ultima mutare

        const std::set <Turn>& get_legal_moves(void) const;
        std::set<CheckerMove> get_immediately_legal_moves(void) const; // returneaza mutarile de cate o pula imediat legale(prima data cele obligatorii)
        std::multiset<int> get_remaining_moves(void) const; // returneaza mutarile ramase
        bool is_turn_done(void) const; // verifica daca s-a facut o tura completa legala
    };

• Cometariile de o linie vin pe aceeasi linie cu codul
• Exceptie se fac la blocurile de cod unde vin pe prima linie a blocului de cod. Ex:

void functie(void)
{
    // aceasta functie face bla, bla bla
    int a = 2, b = 4;
    if(a == b)
    {
        // acest cod se executa daca a si b sunt egale
        fa_ceva();
    }
}

###Prioritati in fisiere:

/*Comentariu despre rolul fisierului*/
* #includeri
* #definiri
* enumerari
* clase
* definitii metode

###Misc.

• Se folosete auto pe cat de mult posibil.