Convenții de cod - C

Acest document descrie regulile ce trebuie respectate la scrierea de programe în C, atât pentru materia Programarea Calculatoarelor cât și pentru Structuri de Date și Algoritmi. Nerespectarea acestor reguli va duce la depunctarea implementării respective.

Identificatori

Numele de variabile urmează convenția CamelCase, cu excepția numelor de macrouri și constante statice care vor urma convenția snake_case și care vor fi scrise exclusiv cu litere mari.

În același timp toți identificatorii trebuie sa aibă nume sugestive, care să descrie fără ambiguitate scopul sau funcționalitatea variabilei sau funcției. Excepție o fac variabilele contor pentru bucle cu nume consacrate: i, j, k și variabile ce memorează coordonate într-un plan: x, y, z.

Nume de variabile

Numele de variabile locare sau argumente

Numele de variabile locale sau argumente de funcții vor incepe cu literă mică și vor urma convenția CamelCase:

void printMyName(char name[]) {
    int variableName;
    float floatValue;
    //...
}

Numele de variabile globale

Numele de variabile globale trebuie să înceapă cu litera 'g' și următoarea literă mare și vor urma convenția CamelCase. Litera 'g' specifică faptul că variabila este globală și nu este definită în contextul curent:

long long gCurrentTime;

void updateCurrentTime(long interval) {
    gCurrentTime += interval;
}

Numele de macrouri și constante statice

Numele de macrouri și constante statice vor urma convenția snake_case și vor fi scrise exclusiv cu litere mari:

#define MAX_STRING_LENGTH 100
#define MAX(x, y) ((x) >= (y) ? (x) : (y))

static const MAX_CLIENTS = 1000;

Numele de funcții

Numele de funcții vor urma convenția CamelCase și vor începe cu literă mică:

int addValues(int, int);
float convertValue(float);
void printData(struct Person person);

Numele de structuri

Numele de structuri vor urma convenția CamelCase și vor începe cu literă mare:

struct Person {
    char name[50];
    unsigned short age;
    char cnp[14];
};

struct DataStore {
    struct Person people[];
    long long rsaKey;
};

Spații

1. Se pun spații înainte și după operatorii binari (=, ==, !=, <, etc.):

   int result = operand1 + operand2 / operand3;
   

2. NU se pun spații înainte operatorii unari (!, -, ++, --, etc.) și operand:

   int result = operand1++ + -operand2;
   int canUse = !isEmpty && !isFull;
   

3. În cazul blocurilor for, while și if se pun spații înainte de parenteza deshisă și după cea închisă:

   while (true) {
       //...
   }
   
   for (i = 0; i < n; i++) {
       //...
   }
   
   if (a == b) {
       //...
   }
   

4. În cazul funcțiilor, NU se lasă spațiu între numele funcției și paranteza deschisă, dar se lasă un spațiu după cea închisă:

   int computeValue(int operand1, float operand2) {
       return (int)(operand1 / operand2);
   }
   

5. Se lasă un spațiu după separatoare (punct-și-virgulă sau virgulă):

   for (i = 0; i < n; i++, j++) {
       //...
   }
   

Indentare

Indentarea se realizează cu spații, nu cu caractere tab, iar o indentare are dimensiunea de 4 spații. Regulile de indentare sunt cele specificate în convenția 1TBS (One True Brace Style) cu observația că acolada de la începutul unei funcții este plasată pe aceeași linie cu definiția funcției.

Blocuri de instrucțiuni

Un bloc de instrucțiuni începe cu o acoladă deschisă care se plasează întotdeauna la sfârșitul unei liniei, iar acoloada închisă se plasează sub primul caracter de pe linia unde s-a deschis blocul de instrucțiuni. Toate instrucțiunile dintr-un bloc de instrucțiuni se aliniază cu o indentare mai mult decât cele din blocul imediat superior:

int computeSad(int vector1[], int vector2[], int vectorLength) {
    int i;
    int sad = 0;
    for (i = 0; i < vectorLength; i++) {
        int difference = vector1[i] - vector2[i];
        if (difference < 0) {
            difference = -difference;
        }
        sad += difference;
    }
    return sad;
}

Utilizarea blocurilor de instrucțiuni

Blocurile de instrucțiuni se vor folosi inclusiv pentru for, if și while, chiar dacă acestea au o singură instrucțiune:

int vectorSum(int v[], int n) {
    int sum = 0;
    for (i = 0; i < n; i++) {
        sum += v[i];
    }
    return sum;
}

Singura excepție o fac blocurile if care se pot scrie citeț pe o singură linie:

int vectorSum(int v[], int n) {
    if (n == 0) return 0;
    int sum = 0;
    for (i = 0; i < n; i++) {
        sum += v[i];
    }
    return sum;
}

Linii lungi

O linie care depășeșete 120 de caractere poate fi scrisă pe două sau mai multe linii, spărgând-o după oricare operator și indentând următoare secțiune din linie cu două indenturi (8 spații):

int computeSum(int value1, int value2, int value2, int value4, int value5, int value6, int value7,
        int value8, int value9, int value10, int value11, int value12, int value13, int value14,
        int value15) {
    
    return value1 + value2 +...;
}

Reguli suplimentare

1. Variabilele se declară fiecare pe o linie diferită:

   float gMyFloatVAriable;
   float gSomeOtherFloatVar;
   
   void someFunction() {
       int variableName;
       int someOtherVariable;
       int i;
       
   }