Structura și stilul programării C

Aceasta este o introducere de bază în stilul de codare bun în limbajul de programare C. Este conceput pentru a oferi informații despre cum să utilizați eficient indentarea, comentariile și alte elemente care vă vor face codul C mai lizibil. Nu este un tutorial despre programarea reală în C.

În calitate de programator începător, scopul creării structurii în codul programului ar putea să nu fie clar, deoarece compilatorului nu îi pasă de diferență. Cu toate acestea, pe măsură ce programele devin complexe, sunt șanse ca scrierea programului să devină un efort comun. (Sau alții ar putea dori să vadă cum a fost realizat. Sau poate fi necesar să-l citiți din nou ani mai târziu.) Codul bine scris vă ajută, de asemenea, să obțineți o imagine de ansamblu asupra a ceea ce face codul.

În secțiunile următoare, vom încerca să explicăm bunele practici de programare care, la rândul lor, vor face programele dvs. mai clare.

Introducere

În C, programele sunt compuse din instrucțiuni. Instrucțiunile se termină cu punct și virgulă și sunt colectate în secțiuni cunoscute sub numele de funcții. Prin convenție, o declarație ar trebui să fie păstrată pe propria linie, așa cum se arată în exemplul de mai jos:

 #include <stdio.h>
  
 int main(void) {
 	printf("Hello, World!\n");
 	return 0;
 }

Următorul bloc de cod este în esență același. Deși conține exact același cod și se va compila și se va executa cu același rezultat, eliminarea spațierii cauzează o diferență esențială: este mai greu de citit.

 #include <stdio.h>
 int main(void) {printf("Hello, World!\n");return 0;}

Utilizarea simplă a indentărilor și a întreruperilor de linie poate îmbunătăți considerabil lizibilitatea codului fără a afecta performanța codului. Codul care poate fi citit face mult mai ușor să vezi unde se termină funcțiile și procedurile și ce linii fac parte din bucle și proceduri.

Această lecție se va concentra pe îmbunătățirea stilului de codare al unui exemplu de cod care aplică o formulă și imprimă rezultatul. Mai târziu, veți vedea cum să scrieți codul pentru astfel de sarcini mai detaliat. Pentru moment, concentrați-vă pe modul în care arată codul, nu pe ceea ce face.

Rupere de linie și indentare

Adăugarea de spațiu alb în codul dvs. este probabil cea mai importantă parte a unei structuri bune a codului. Utilizarea eficientă a spațiului alb poate crea o scară vizuală a modului în care codul dvs. curge, ceea ce poate fi foarte important atunci când reveniți la codul dvs. atunci când doriți să îl mențineți.

Rupere de linie

Nota: Observați utilizarea numerelor de rând. Ele nu fac parte din codul propriu-zis. Sunt doar pentru referință.

Cu întreruperi de linie minime, codul abia poate fi citit de om și poate fi greu de depanat sau de înțeles:

#include <stdio.h>
int main(void) { int revenue = 80; int cost = 50; int roi; roi = (100 * (revenue - cost)) / cost; if (roi >= 0) { printf ("%d\n", roi); } return 0; }

În loc să puneți totul pe o singură linie, este mult mai ușor să despărțiți rândurile lungi, astfel încât fiecare declarație și declarație să meargă pe propria linie. După inserarea întreruperilor de linie, codul va arăta astfel:

#include <stdio.h>
int main(void) {
int revenue = 80;
int cost = 50;
int roi;
roi = (100 * (revenue - cost)) / cost;
if (roi >= 0) {
printf ("%d\n", roi);
}
return 0;
}

Linii goale

Ar trebui folosite linii goale pentru a compensa principalele componente ale codului dvs. Folosiți-le întotdeauna

După directivele preprocesorului.
După ce sunt declarate variabile noi.
Folosiți-vă propria judecată pentru a găsi alte locuri unde componentele ar trebui separate.

Pe baza acestor două reguli, acum ar trebui să fie adăugate cel puțin două întreruperi de linie.

După linia 1, deoarece linia 1 are o directivă de preprocesor.
După linia 5, deoarece linia 5 conține o declarație de variabilă.

Acest lucru va face codul mult mai lizibil decât era înainte:

Următoarele linii de cod au întreruperi de linie între funcții, dar fără indentare.

#include <stdio.h>

int main(void) {

int revenue = 80;
int cost = 50;

int roi;

roi = (100 * (revenue - cost)) / cost;

if (roi >= 0) {
printf ("%d\n", roi);
}

return 0;
}

Dar încă nu este atât de lizibil pe cât poate fi.

Indentare

Mulți editori de text indentează automat în mod corespunzător atunci când apăsați tasta Enter/Return.

Deși adăugarea de întreruperi de linie simple între blocurile cheie de cod poate face codul mai ușor de citit, nu oferă informații despre structura blocurilor programului. Utilizarea tastei Tab poate fi foarte utilă. Indentarea separă vizual căile de execuție prin mutarea punctelor lor de pornire într-o nouă coloană. Această practică simplă va face mult mai ușor de citit și de înțeles codul. Indentarea urmează o regulă destul de simplă:

Tot codul din interiorul unui bloc nou ar trebui să fie indentat cu o filă [1] mai mult decât codul din calea anterioară.

Pe baza codului din secțiunea anterioară, există două blocuri care necesită indentare:

Liniile de la 4 la 16
Linia 13

#include <stdio.h>

int main(void) {

    int revenue = 80;
    int cost = 50;

    int roi;

    roi = (100 * (revenue - cost)) / cost;

    if (roi >= 0) {
        printf ("%d\n", roi);
    }

    return 0;
}

Acum este destul de evident ce părți ale programului se încadrează în blocuri. Puteți spune care părți ale programului a intenționat codificatorul să fie condiționate și care nu. Deși s-ar putea să nu fie vizibil imediat, odată ce multe căi imbricate sunt adăugate la structura programului, utilizarea indentării poate fi foarte importantă. Astfel, indentarea face structura programului dumneavoastră clară.

Se susține că cercetările au arătat că o dimensiune a indentației între 2 și 4 caractere este mai ușor de citit decât 8 indentări de caractere [2]. Cu toate acestea, o indentație de 8 caractere poate fi încă utilizată pentru unele sisteme [3].

Comentarii

Comentariile din cod pot fi utile pentru o varietate de scopuri. Ele oferă cel mai simplu mod de a declanșa anumite părți ale codului (și scopul lor); precum și oferirea unei „împărțiri” vizuale între diferite părți ale codului dvs. Dacă aveți comentarii bune în codul dvs., vă va fi mult mai ușor să vă amintiți ce fac anumite părți ale codului.

Comentariile în versiunile moderne ale C (și multe alte limbi) pot veni în două forme:

//Comentarii pe o singură linie (adăugat de standardul C99, cunoscut sub numele de stilul de comentarii C++))

și

/*Comentarii
multi-linii
(singura formă de comentarii acceptată de standardul C89)*/

Rețineți că comentariile cu o singură linie sunt o adăugare mai recentă la C, așa că este posibil ca unele compilatoare să nu le accepte. O versiune recentă a Colecției de compilatoare GNU (GCC) nu va avea probleme în a le suporta.

Această secțiune se va concentra asupra diferitelor utilizări ale fiecărei forme de comentariu.

Comentarii pe o singură linie

Comentariile pe o singură linie sunt cele mai utile pentru notele „laterale” simple care explică ce fac anumite părți ale codului. Cele mai bune locuri pentru a pune aceste comentarii sunt lângă declarațiile variabile și lângă bucăți de cod care ar putea avea nevoie de explicații. Comentariile ar trebui să clarifice intenția și ideile din spatele codului corespunzător. Ceea ce este imediat evident din citirea codului nu aparține unui comentariu.

Pe baza programului nostru anterior, există diverse locuri bune pentru a face comentarii

Rândul 5 și/sau 6, pentru a explica ce reprezintă „venitul intern” și „costul intern”,
Linia 8, pentru a explica pentru ce va fi folosită variabila „roi”,
Linia 10, pentru a explica ideea calculului,
Rândul 12, pentru a explica scopul lui „if”.

Acest lucru va face ca programul nostru să arate ceva asemănător cu

#include <stdio.h>

int main(void) {

    int revenue = 80;               // din 2016
    int cost = 50;

    int roi;                        // rentabilitatea investiției în procente

    roi = (100 * (revenue - cost)) / cost;  // formula din contabilitate

    if (roi >= 0) {                 // nu ne pasă de roi negativ
        printf ("%d\n", roi);
    }

    return 0;
}

Comentarii pe mai multe linii

Comentariile pe o singură linie sunt o caracteristică nouă, așa că mulți programatori C folosesc doar comentarii pe mai multe linii.

Comentariile pe mai multe linii sunt cele mai utile pentru explicațiile lungi ale codului. Ele pot fi folosite ca notificări privind drepturile de autor/licențiere și pot fi folosite și pentru a explica scopul unui bloc de cod. Acest lucru poate fi util din două motive: vă fac funcțiile mai ușor de înțeles și vă ajută să identificați erorile în cod. Dacă știi ce ar trebui să facă un bloc, atunci este mult mai ușor să găsești fragmentul de cod care este responsabil dacă apare o eroare.

De exemplu, să presupunem că avem un program care a fost conceput pentru a tipări „Hello, World!” un anumit număr de linii, un anumit număr de ori. Ar fi multe bucle for în acest program. Pentru acest exemplu, vom numi numărul de linii i și numărul de șiruri pe linie ca j.

Un bun exemplu de comentariu pe mai multe linii care descrie scopul buclei „for” i ar fi:

 /* Bucla for (int i)
    Face bucle la următoarea procedură de i ori (pentru numărul de linii). Efectuează bucla „for” j pe fiecare buclă,
    și imprimă o nouă linie la sfârșitul fiecărei bucle.
 */

Aceasta oferă o bună explicație a scopului lui i, fără a intra în detaliu despre ceea ce face j. Intrând în detalii despre ceea ce face calea specifică (și nu cele din interiorul acesteia), va fi mai ușor să depanați calea.

În mod similar, ar trebui să includeți întotdeauna un comentariu pe mai multe linii înainte de fiecare funcție, pentru a explica rolul, precondițiile și postcondițiile fiecărei funcții. Lăsați întotdeauna detaliile tehnice pentru blocurile individuale din cadrul programului dvs. – acest lucru facilitează depanarea.

Un descriptor de funcție ar trebui să arate cam așa:

 /* Funcția : int hworld (int i,int j)
    Intrare    : int i (Numărul de linii), int j (Numărul de instanțe per linie)
    Ieșire   : 0 (pe succes)
    Procedura: Imprimă "Hello, World!" de j ori, și o nouă linie la ieșirea standard peste i linii.
 */

Acest sistem permite o explicație dintr-o privire a ceea ce ar trebui să facă funcția. Apoi, puteți intra în detaliu asupra modului în care fiecare aspect al programului este realizat mai târziu în program.

În cele din urmă, dacă doriți să aveți un cod sursă plăcut din punct de vedere estetic, sistemul de comentarii cu mai multe linii permite adăugarea ușoară a casetelor de comentarii. Acestea fac comentariile să iasă în evidență mult mai mult decât ar fi altfel. Ele arată așa.

 /***************************************
  *  Acesta este un comentariu pe mai multe linii
  *  Acesta este înconjurat îndeaproape de
  *  un chenar înstelat, frumoas!
  ***************************************/

Aplicat programului nostru original, acum putem include un cod sursă mult mai descriptiv și mai ușor de citit:

#include <stdio.h>

int main(void){
    /************************************************************************************
     * Funcția  : int main(void)
     * Intrare  : niciuna
     * Ieșire   : Returnează 0 pe succes
     * Procedura: Imprimă rentabilitatea investiției din 2016 în procente dacă nu este negativă.
     ************************************************************************************/
    int revenue = 80;               // fin 2016
    int cost = 50;

    int roi;                        // rentabilitatea investiției în procente

    roi = (100 * (revenue - cost)) / cost;  // formula din contabilitate

    if (roi >= 0) {                 // nu ne pasă de roi negativ
        printf ("%d\n", roi);
    }

    return 0;
}

Acest lucru va permite oricăror utilizatori externi ai programului o modalitate ușoară de a înțelege care sunt funcțiile codului și cum funcționează acestea. De asemenea, inhibă incertitudinea cu alte funcții asemănătoare.

Câțiva programatori adaugă o coloană de stele în partea dreaptă a unui comentariu de bloc:

 /***************************************
  *  Acesta e un comentariu multilinii  *
  *  complet înconjurat de              *
  *  un chenar înstelat, frumos!        *
  ***************************************/

Dar majoritatea programatorilor nu pun nicio stea în partea dreaptă a unui comentariu de bloc. Ei simt că alinierea părții drepte este o pierdere de timp.

Comentariile scrise în fișierele sursă pot fi folosite pentru a documenta codul sursă în mod automat, folosind instrumente populare precum Doxygen.[4][5]

Referințe

Mai mulți programatori recomandă să „utilizați spații pentru indentare. Nu folosiți file în codul dvs. Ar trebui să setați editorul să emită spații atunci când apăsați tasta Tab”. [1] [2] Alți programatori nu sunt de acord. [3] [4] Indiferent dacă preferați spații sau file, asigurați-vă că păstrați consecvența în cadrul proiectelor la care lucrați. Amestecarea filelor și a spațiilor poate face codul să devină ilizibil.
http://www.oualline.com/vim/vim-cook.html#drawing Vim cookbook
https://www.kernel.org/doc/html/latest/process/coding-style.html Linux Kernel Coding Style
„Coding Conventions for C++ and Java” „Toate comentariile de bloc ilustrate în acest document nu au stele frumoase în partea dreaptă a comentariului de bloc. Această alegere deliberată a fost făcută deoarece alinierea acestor stele frumoase este o mare pierdere de timp și descurajează menținerea comentariilor în linie.”
c2:BigBlocksOfAsterisks,„Code craft” de Pete Goodliffe pagina 82,Falvotech „C Programming Style Guide”, Fedora Directory Server Coding Style