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

De la WikiLabs
(Reguli suplimentare)
 
(Nu s-au afișat 51 de versiuni intermediare efectuate de același utilizator)
Linia 1: Linia 1:
During the DSA lab and while solving homework, you will also get points for the way the source code is paged, tabbed, the naming of the functions and variables, and the general structure of the program. The conventions that need to be followed are:
+
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.
* the segments of the file should appear in the following order:
 
** header comment, describing the role of the file, author and the project it is part of;
 
** import directives;
 
** define directives;
 
** data types (new structures or typedefs);
 
** global variables (these you should avoid in most cases);
 
** function prototypes;
 
** function implementations; each implementation should have a short comment explaining the function role, the arguments and the return type;
 
** footer comment, describing the changes in the file (this may be missing if the file is not under version control - svn, git, perforce, etc.);
 
* all segments of the file are split by a comment-line which appears also between functions;
 
* the main function, if it exists, is placed first;
 
* for if / do-while / for / case constructs and for method bodies, the open curly bracket is placed on the same line with the construct / function declaration and the closed curly bracket is placed on a separate line, on the same column with first letter from the construct/ declaration;
 
* an instruction block is indented by one extra tab in respect to the previous level;
 
* new data type names (as well as structures) start with an uppercase letter;
 
* function and variable names start with a lowercase letter;
 
* global variables start with a lowercase "g": (int g_my_global_var; or int gMyGlobalVar;)
 
* constant names are written in caps, words separated by the "_" character;
 
* the naming must be as explicit as possible regarding their purpose, in order to avoid excessive comments;
 
* it is allowed to insert a blank line, if a natural segregation of elements is obtained through it.  
 
  
Notes:
+
= Identificatori =
* your code editor should be configured so that instead of a TAB character, it should insert 4 spaces;
 
* both camel case and underscore-separated words are accepted, as long as the notation is consistent throughout the program; so pick one and stick with it.
 
  
 +
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.
  
== Example ==
+
Î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 ==
 +
 
 +
=== 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]:
 +
<syntaxhighlight lang="C">
 +
void printMyName(char name[]) {
 +
    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">
 
<syntaxhighlight lang="C">
/*******************************************************************
+
struct Person {
*          Coding Conventions Style Example
+
    char name[50];
*         
+
    unsigned short age;
* Author: Radu Hobincu
+
    char cnp[14];
* Date: 09.03.2014
+
};
* Description: This file contains functions and variables used
+
 
*         to exemplify the use of coding styles and how the
+
struct DataStore {
*         readability of a program improves when it is well written.
+
    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) {
 +
    //...
 +
}
 +
 
 +
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;
    
}