// funktion til at beregne kvadratet for et tal
int firkant (int x) {
int resultat =x * x;
// Postcondition:Resultat skal være ikke-negativt (hvis X er et heltal)
hævde (resultat> =0); // Dette kan mislykkes på grund af heltaloverløb, hvis X er meget stort.
Returresultat;
}
int main () {
int resultat =firkant (5);
printf ("firkant med 5:%d \ n", resultat);
int stor_number =100000; // kan forårsage overløb
resultat =firkant (stor_number); // postkondition kan mislykkes på grund af overløb.
printf ("firkant med %d:%d \ n", stor_number, resultat);
return 0;
}
`` `
I dette eksempel har funktionen `firkantet 'en postkondition, som' resultat 'skal være ikke-negativt (forudsat at' x 'er et heltal). `Assert (resultat> =0)` erklæring kontrollerer denne postkondition. Hvis resultatet er negativt (for eksempel på grund af heltaloverløb), vil påstanden mislykkes.
Nøgleforskelle opsummeret:
| Funktion | Forudsætning | Postkondition |
| ---------------- | -------------------------------------------------- | ---------------------------------------------------- |
| timing | Kontrolleret * før * Funktionen udføres | Kontrolleret * efter * funktionen udføres |
| ansvar | Opkalder af funktionen | Funktion i sig selv |
| Formål | Definer forventet input og miljø | Definer garanteret opførsel og effekt af funktionen |
| overtrædelse | Angiver et problem i * opkaldskoden * | Angiver et problem * inden for funktionen * |
| garantier | Funktionen kan fungere korrekt | Funktionen har opnået sin tilsigtede effekt |
Sådan implementeres i C:
Da C ikke har indbygget støtte til forudsætninger og postkonditioner, er standardmetoden at bruge:
1. :Dette er den mest almindelige måde at kontrollere betingelserne på. Påstande er typisk aktiveret i debug-builds (f.eks. Med `-ddebug`-kompilatorflagget) og deaktiveret i udgivelsesbygninger. Dette betyder, at kontrollerne sker under udviklingen, men er optimeret væk i det endelige produkt for at undgå præstationsomkostninger.
2. `#ifdef debug` -blokke :Du kan også bruge `#IFDEF Debug 'til betinget at omfatte mere kompleks forudsætning og postkonditionskontrol, der kan involvere mere end en simpel sammenligning.
3. kommentarer :Selv hvis du ikke bruger påstande, er det vigtigt at dokumentere forudsætninger og postkonditioner i kommentarer for at gøre din kode mere forståelig.
4. testrammer: Overvej at bruge testrammer, der understøtter kontrol før/efter konditionen for at lette enhedstest.
Eksempel med kombinerede forudsætninger, postkonditioner og kommentarer:
`` c
#Include
#include
/**
* @Brief beregner kraften i et tal (base hævet til eksponent).
*
* @param base basisnummeret (heltal).
* @param eksponent eksponenten (ikke-negativt heltal).
*
* @pre eksponent> =0 (eksponent skal være ikke-negativ).
* @pre base! =0 || Eksponent! =0 (base og eksponent ikke begge 0 - undgår udefineret opførsel)
*
* @post returnerer base, der er hævet til eksponentens magt.
* @post hvis eksponent er 0, er resultatet 1 (undtagen base =0, som ikke er tilladt).
*
* @Return resultatet af base hævet til eksponentens magt.
* Returnerer 1 Hvis eksponent er 0.
*/
int magt (int base, int eksponent) {
// forudsætninger:
hævde (eksponent> =0);
hævde (base! =0 || eksponent! =0); // forhindre udefineret opførsel med 0^0
int resultat =1;
for (int i =0; i
resultat *=base;
}
// postkonditioner:
if (eksponent ==0) {
hævde (resultat ==1); // Kontroller for basiskasse
}
Returresultat;
}
int main () {
int resultat =magt (2, 3); // 2^3 =8
printf ("2^3 =%d \ n", resultat);
Resultat =strøm (5, 0); // 5^0 =1
printf ("5^0 =%d \ n", resultat);
// strøm (0,0); // Dette vil udløse påstanden.
return 0;
}
`` `
Fordele ved at bruge forudsætninger og postkonditioner:
* Forbedret kodekvalitet: De tvinger dig til at tænke nøje over antagelserne og garantier for dine funktioner.
* lettere fejlfinding: Påstande hjælper med at fange fejl tidligt og præcisere kilden til problemer.
* bedre dokumentation: De dokumenterer helt klart den forventede opførsel af dine funktioner.
* øget vedligeholdelighed: De gør din kode lettere at forstå og ændre, hvilket reducerer risikoen for at indføre fejl.
* formel verifikation: I nogle tilfælde kan forudsætninger og postkonditioner bruges med formelle verifikationsværktøjer til at bevise rigtigheden af din kode.
Ved at inkorporere forudsætninger og postkonditioner i din C -kode (selvom du bare bruger kommentarer og påstande), kan du skrive mere robust, pålidelig og vedligeholdelig software.
