I databehandling er en rutine en databehandlingsenhed, der indkapsler en del af koden (en sekvens af instruktioner ), der udfører en velidentificeret specifik behandling (slaveri, opgave, beregning osv.) Relativt uafhængig af resten af programmet, og som kan genbruges. i det samme program eller i et andet. I dette tilfælde opbevares rutinen ofte i et bibliotek for at gøre den tilgængelig for andre programmeringsprojekter, samtidig med at integriteten af dens implementering bevares.
Rutiner giver dig mulighed for at opdele et problem ved at nedbryde det program, der skal udføres i stykker kode, der er lettere at producere, bruge, administrere og vedligeholde. Instruktionerne, der udfører rutinen, er indkapslet inde i den, og programmøren kan ringe til rutinen uden at bekymre sig om de interne detaljer i denne; rutinen spiller rollen som en sort boks i de rutiner, der bruger den.
I computerprogrammering finder vi rutiner i to hovedformer:
proceduren | En rutine, der ikke returnerer nogen værdi, udfører en veldefineret operation (opgave), hvis brug spiller rollen som en ad hoc- instruktion . |
fungere | En rutine, der returnerer en og kun en værdi i henhold til den matematiske definition af funktion . |
En rutine er kun effektiv, hvis den returnerer mindst en værdi til opkaldsrutinen eller (inklusive), hvis den har en indvirkning på sit miljø (læsning af en sensor , skrivning til en aktuator , ændring af en global variabel osv.).
foruddefineret rutine | En rutine, der ofte leveres i et bibliotek , som kan bruges uden at skulle definere den, hvis vi kender erklæringen og dens rolle. |
dummy rutine | En rutine, der midlertidigt under programudviklingen ikke gør noget (rutinen er tom). |
Metode | En rutine, der er medlem af en klasse (i objektorienteret programmering ) |
I de fleste programmeringssprog , den erklæring (og dermed definition) af en rutine omfatter normalt:
I tilfælde af en funktion inkluderer erklæringen om en rutine også:
På nogle programmeringssprog, der tillader det, hvilket er sjældent i dag (2016), angives den udvekslingstilstand, der er knyttet til hver parameter:
Alle disse elementer vises ikke nødvendigvis på alle programmeringssprog .
Underskriften (profilen) af en rutine eller navnedekoration gør det muligt for oversætteren ( kompilator , tolk osv.) At kontrollere, at rutinen bruges på en måde, der er i overensstemmelse med dens erklæring. Det giver også linkeren (linker) mulighed for at etablere linket med den tilsvarende rutine.
Signaturen bruger normalt:
I de nuværende (2013) implementeringer af programmeringssprog modtages en kopi af argumenterne fra den kaldende rutine i parametrene for den kaldte rutine (påkaldt rutine) i stedet for at arbejde på de faktiske variabler i den kaldende rutine, hvilket ikke altid var sandt i 1960'erne (for eksempel i FORTRAN IV).
Ikke desto mindre er det altid muligt at arbejde på de reelle variabler, hvis disse er blevet erklæret "globale", men det er en kilde til fare, og det er ikke "bærbart". Dette kaldes derefter en kanteffekt .
Imidlertid anmoder rutiner ofte hukommelsesadressen for at kalde rutinevariabler (argumenter) snarere end deres værdier. Denne mekanisme bruger en markør (eller en reference i C ++ , Perl eller PHP ). Normalt returnerer en rutine af hensyn til modularitet ikke en værdi ved at ændre variablerne i den kaldende rutine (argumenter). For eksempel i Fortran er dette strengt forbudt af sprogspecifikationerne og detekteret af kompilatorerne. En funktion kan returnere et enkelt resultat med sin returværdi. Dette resultat kan blandt andet være:
Rutinens krop inkluderer:
Enten ved at skrive tre tal i stigende rækkefølge har vi for eksempel:
Kodet | Forklaring |
---|---|
programme p1; | |
// Variables globales au programme. réel r1, r2, r3 ;
|
|
//********************************************
fonction min(réel a, b) : réel;
début
// Déterminer la valeur minimale.
si a < b alors
min := a ;
sinon
min := b ;
fin min;
|
Brug som i matematik, de min og max funktioner, der er defineret her:
Den maksimale rutine :
|
//********************************************
action classeETsort(réel a, b, c)
// Variables locales à la procédure.
réel inf, sup ;
début
// inf reçoit la plus petite valeur.
inf:= min(a, min(b, c));
// sup reçoit la plus grande valeur.
sup:= max(a, max(b, c));
// Afficher le triplet ordonné.
écrire (inf, a+b+c-inf-sup, sup) ;
fin classeETsort;
|
ClassETsort- proceduren (eller handling) :
|
//******************************************** début // Lire les 3 valeurs à trier. lire(r1); lire(r2); lire(r3 ); // Trier les 3 valeurs et les afficher // en utilisant la procédure classeETsort. classeETsort(r1, r2, r3); fin p1.
|
Programmets hovedrutine:
Den read (i de vigtigste rutine) og skrive (i classETsort rutine ) rutiner antages at være foruddefineret; |
int max ( int a, int b ) { return a > b ? a : b; } | Funktionen maxhar parametre aog bheltal ( int) og returnerer en heltalværdi ( int).
Seler {og }afgrænser funktionens krop. Funktionens navn ( max) beskriver den operation, den udfører; det returnerer den maksimale værdi mellem aog b. Dette er ikke en forpligtelse for sproget, men udgør god programmeringspraksis: navnet på funktionen er kun af mnemonisk betydning, dens adfærd afhænger kun af instruktionerne i dens krop. På nogle sprog er navnet på funktionen særlig vigtig. For eksempel i C ++ skal konstruktører og destruktorer navngives efter den tilsvarende klasse. |
int main ( int argc, char *argv[] ) { //... printf ( "La valeur maximum est %i.\n", max(123,456) ); //... return 0; } | Den vigtigste funktion ( main) anvender funktionen max(kaldet "funktionskald") i funktionen argument printf : max(123, 456). |
Ikke alle programmeringssprog implementerer begge former for rutiner. De sprog, der implementerer de to former for rutiner, forbeholder sig et nøgleord til at skelne dem under deres erklæring.
Sprog | Procedure | Fungere |
---|---|---|
Lisp | Specielt tilfælde af funktion | defun |
C , C ++ | Særligt tilfælde af funktion: særlig returtype void | Intet nøgleord |
Pascal | PROCEDURE | FUNCTION |
Fortran | subroutine | function |
Algol | procedure | Specielt tilfælde af proceduren |
Med visse programmeringssprog er de to begreber tæt, idet der kun skelnes mellem at returnere en værdi eller ikke, eller når en procedure finder sted af funktion med flere resultater, eller hvis en funktion udfører operationer ved indgang. / Exit.
På den anden side, i tilfælde af sprog, der ved siden af procedurer kun tillader rene funktioner , er de to begreber meget forskellige.
For eksempel er i C / C ++ eller i Lisp alle rutiner funktioner; dette er grunden til, at sprogdokumentationen kun taler om funktion. På den anden side giver C / C ++ sprogsproget den type, voidder gør det muligt at erklære en funktion, der ikke returnerer noget, for at have svarende til proceduren og let konvertere programmer skrevet på sprog med procedurer . gør derved en procedure.
I C / C ++ overses returværdien af visse funktioner, såsom printf()(skriv til stdout-outputstrømmen) eller scanf()(læst til stdin-inputstrømmen), som rapporterer deres udførelse, oftere af den rutine, der bruger den; de spiller derfor i det væsentlige en efterforskningsrolle som en procedure.
I Algol W returnerer enhver rutine en værdi, som vi kan bruge eller ej, der svarer til C-sprogtilgangen.
PL / I betragter kun en procedure som en funktion, hvis resultat ikke huskes, hvilket også ligner C-sprogtilgangen. På den anden side skelner sprog som Fortran , Algol 60 , BASIC , Pascal , Modula 2 klart begge begreber ved hjælp af nøgleord .
Erklæring | Definition | |
---|---|---|
Fungere | int somme(int var1, int var2); | int somme(int var1, int var2) { return var1 + var2; } |
Procedure | void afficher(int var); | void afficher (int var) { printf ("Valeur = %i\n", var) ; return; } |
Wirth N., Algoritmer og datastrukturer , Eyrolles, 1980, trad. de Algorithms + Datastrukturer = Programmer , 1976, Prentice-Hall-serien i automatisk beregning.