Convenții de cod - C: Diferență între versiuni

De la WikiLabs
(Reguli suplimentare)
 
(Nu s-au afișat 35 de versiuni intermediare efectuate de același utilizator)
Linia 1: Linia 1:
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.
+
Acest document descrie regulile ce trebuie respectate la scrierea de programe în C, pentru materia Programarea Calculatoarelor. Nerespectarea acestor reguli poate duce la depunctarea implementării respective.
  
 
= Identificatori =
 
= Identificatori =
  
Numele de variabile urmează convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase], cu excepția numelor de macrouri și constante statice care vor urma convenția [https://en.wikipedia.org/wiki/Snake_case snake_case] și care vor fi scrise exclusiv cu litere mari.
+
Numele de variabile urmează convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase], cu excepția numelor de macrouri și constante statice care vor urma convenția [https://en.wikipedia.org/wiki/Snake_case 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 variabilei sau funcției. Excepție o fac variabilele contor pentru bucle cu nume consacrate: <code>i</code>, <code>j</code>, <code>k</code> și variabile ce memorează coordonate într-un plan: <code>x</code>, <code>y</code>, <code>z</code>.
  
 
== Nume de variabile ==
 
== Nume de variabile ==
  
=== Numele de variabile locare sau argumente ===
+
=== Numele de variabile locale sau argumente ===
  
 
Numele de variabile locale sau argumente de funcții vor incepe cu literă mică și vor urma convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase]:
 
Numele de variabile locale sau argumente de funcții vor incepe cu literă mică și vor urma convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase]:
 
<syntaxhighlight lang="C">
 
<syntaxhighlight lang="C">
int variableName;
+
void printMyName(char name[]) {
float floatValue;
+
    int variableName;
 +
    float floatValue;
 +
    //...
 +
}
 +
</syntaxhighlight>
 +
 
 +
=== Numele de variabile globale ===
 +
 
 +
Numele de variabile globale trebuie să înceapă cu litera 'g' și următoarea literă mare și vor urma convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase]. Litera 'g' specifică faptul că variabila este globală și nu este definită în contextul unei funcții:
 +
 
 +
<syntaxhighlight lang="C">
 +
long long gCurrentTime;
 +
 
 +
void updateCurrentTime(long interval) {
 +
    gCurrentTime += interval;
 +
}
 +
</syntaxhighlight>
 +
 
 +
=== Numele de macrouri, constante statice sau elemente din <code>enum</code> ===
 +
 
 +
Numele de macrouri, constante statice sau elemente din <code>enum</code>, vor urma convenția [https://en.wikipedia.org/wiki/Snake_case snake_case] și vor fi scrise exclusiv cu litere mari:
 +
 
 +
<syntaxhighlight lang="C">
 +
#define MAX_STRING_LENGTH 100
 +
#define MAX(x, y) ((x) >= (y) ? (x) : (y))
 +
 
 +
static const MAX_CLIENTS = 1000;
 +
 
 +
enum Colors {
 +
    BLACK = 0,
 +
    BLUE,
 +
    RED,
 +
    WHITE
 +
};
 +
</syntaxhighlight>
 +
 
 +
== Numele de funcții ==
 +
 
 +
Numele de funcții vor urma convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase] și vor începe cu literă mică:
 +
<syntaxhighlight lang="C">
 +
int addValues(int, int);
 +
float convertValue(float);
 +
void printData(struct Person person);
 +
</syntaxhighlight>
 +
 
 +
== Numele de structuri, enumerări sau union ==
 +
 
 +
Numele de structuri, enumerări sau union vor urma convenția [https://en.wikipedia.org/wiki/CamelCase CamelCase] și vor începe cu literă mare:
 +
<syntaxhighlight lang="C">
 +
struct Person {
 +
    char name[50];
 +
    unsigned short age;
 +
    char cnp[14];
 +
};
 +
 
 +
struct DataStore {
 +
    struct Person people[];
 +
    long long rsaKey;
 +
};
 +
 
 +
enum Color {
 +
    BLACK = 0,
 +
    BLUE,
 +
    WHITE
 +
};
 +
 
 +
union IntAndByte {
 +
    int intValue;
 +
    char chars[4];
 +
};
 +
</syntaxhighlight>
 +
 
 +
= Spații =
 +
 
 +
<ol>
 +
<li>Se pun spații înainte și după operatorii binari (=, ==, !=, <, etc.):
 +
<syntaxhighlight lang="C">
 +
int result = operand1 + operand2 / operand3;
 +
</syntaxhighlight>
 +
</li>
 +
<li>'''NU''' se pun spații înainte operatorii unari (!, -, ++, --, etc.) și operand:
 +
<syntaxhighlight lang="C">
 +
int result = operand1++ + -operand2;
 +
int canUse = !isEmpty && !isFull;
 +
</syntaxhighlight>
 +
</li>
 +
<li>În cazul blocurilor <code>for</code>, <code>while</code> și <code>if</code> se pun spații înainte de parenteza deschisă și după cea închisă:
 +
<syntaxhighlight lang="C">
 +
while (true) {
 +
    //...
 +
}
  
void printMyName(char name[]) {
+
for (i = 0; i < n; i++) {
 +
    //...
 +
}
 +
 
 +
if (a == b) {
 +
    //...
 +
}
 +
</syntaxhighlight>
 +
</li>
 +
<li>Î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ă:
 +
<syntaxhighlight lang="C">
 +
int computeValue(int operand1, float operand2) {
 +
    return (int)(operand1 / operand2);
 +
}
 +
</syntaxhighlight>
 +
</li>
 +
<li>Se lasă un spațiu după separatoare (punct-și-virgulă sau virgulă):
 +
<syntaxhighlight lang="C">
 +
for (i = 0; i < n; i++, j++) {
 
     //...
 
     //...
 +
}
 +
</syntaxhighlight>
 +
</li>
 +
</ol>
 +
 +
= Indentare =
 +
Indentarea se realizează cu spații, nu cu caractere <code>tab</code>, iar o indentare are dimensiunea de 4 spații. Regulile de indentare sunt cele specificate în convenția [https://en.wikipedia.org/wiki/Indent_style#Variant:_1TBS 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:
 +
<syntaxhighlight lang="C">
 +
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;
 +
}
 +
</syntaxhighlight>
 +
 +
== Utilizarea blocurilor de instrucțiuni ==
 +
 +
Blocurile de instrucțiuni se vor folosi inclusiv pentru <code>for</code>, <code>if</code> și <code>while</code>, chiar dacă acestea au o singură instrucțiune:
 +
<syntaxhighlight lang="C">
 +
int vectorSum(int v[], int n) {
 +
    int sum = 0;
 +
    for (i = 0; i < n; i++) {
 +
        sum += v[i];
 +
    }
 +
    return sum;
 +
}
 +
</syntaxhighlight>
 +
 +
Singura excepție o fac blocurile <code>if</code> care se pot scrie citeț pe o singură linie:
 +
<syntaxhighlight lang="C">
 +
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;
 +
}
 +
</syntaxhighlight>
 +
 +
== 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):
 +
<syntaxhighlight lang="C">
 +
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 +...;
 +
}
 +
</syntaxhighlight>
 +
 +
== Reguli suplimentare ==
 +
 +
Variabilele se declară fiecare pe o linie diferită:
 +
<syntaxhighlight lang="C">
 +
float gMyFloatVAriable;
 +
float gSomeOtherFloatVar;
 +
 +
void someFunction() {
 +
    int variableName;
 +
    int someOtherVariable;
 +
    int i;
 +
   
 
}
 
}
 
</syntaxhighlight>
 
</syntaxhighlight>

Versiunea curentă din 29 octombrie 2017 20:51

Acest document descrie regulile ce trebuie respectate la scrierea de programe în C, pentru materia Programarea Calculatoarelor. Nerespectarea acestor reguli poate 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 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 locale 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 unei funcții:

long long gCurrentTime;

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

Numele de macrouri, constante statice sau elemente din enum

Numele de macrouri, constante statice sau elemente din enum, 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;

enum Colors {
    BLACK = 0,
    BLUE,
    RED,
    WHITE
};

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, enumerări sau union

Numele de structuri, enumerări sau union 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;
};

enum Color {
    BLACK = 0,
    BLUE,
    WHITE
};

union IntAndByte {
    int intValue;
    char chars[4];
};

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 deschisă ș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

Variabilele se declară fiecare pe o linie diferită:

float gMyFloatVAriable;
float gSomeOtherFloatVar;

void someFunction() {
    int variableName;
    int someOtherVariable;
    int i;
    
}