Subrutine

Den aktuelle version af siden er endnu ikke blevet gennemgået af erfarne bidragydere og kan afvige væsentligt fra den version , der blev gennemgået den 16. oktober 2017; checks kræver 19 redigeringer .

Subrutine ( eng. subroutine ) - en navngivet eller på anden måde identificeret del af et computerprogram, der indeholder en beskrivelse af et specifikt sæt handlinger. En subrutine kan kaldes flere gange fra forskellige dele af programmet. I programmeringssprog er der særlige syntaktiske midler til design og brug af subrutiner.

Formål med underrutiner

Subrutiner dukkede oprindeligt op som et middel til at optimere programmer i forhold til mængden af optaget hukommelse - de gjorde det muligt ikke at gentage identiske kodeblokke i programmet, men at beskrive dem én gang og kalde dem efter behov. Til dato er denne funktion af subrutiner blevet hjælpe, deres hovedformål er at strukturere programmet for at gøre det lettere at forstå og vedligeholde.

At adskille et sæt handlinger i en underrutine og kalde det efter behov giver dig mulighed for logisk at vælge en integreret delopgave, der har en typisk løsning. En sådan handling har endnu en (udover at spare hukommelse) fordel i forhold til gentagne handlinger af samme type: enhver ændring (fejlrettelse, optimering, funktionalitetsudvidelse) foretaget i subrutinen afspejles automatisk i alle dens opkald, mens hver ændring ved duplikering ændring skal foretages i hver forekomst af den mutable kode.
Selv i de tilfælde, hvor et engangssæt af handlinger er allokeret til subrutinen, er dette berettiget, da det gør det muligt at reducere størrelsen af de integrerede kodeblokke, der udgør programmet, det vil sige at gøre programmet mere forståeligt og synlige.

Fordele

Fordelene ved at opdele et program i underrutiner inkluderer:

Dekomponerer en kompleks programmeringsopgave i enkle trin: dette er et af de to vigtigste værktøjer til struktureret programmering og datastrukturer.
Reduktion af duplikeret kode
Mulighed for at genbruge kode i andre programmer
Opdeling af en stor programmeringsopgave mellem forskellige programmører eller forskellige faser af et projekt
Skjuler implementeringsdetaljer fra subrutinebrugere
Sporingsforbedringer (de fleste sprog giver en måde at få et opkaldsspor på, der inkluderer navnene på de involverede underrutiner og måske endnu mere information såsom filnavne og linjenumre). Uden at dekomponere koden i underrutiner ville fejlfinding blive alvorligt hæmmet.

Mekanismen for underrutiner, deres beskrivelse og opkald

I det enkleste tilfælde (i assemblers ) er en underrutine en sekvens af kommandoer (operatører), der er adskilt fra hoveddelen af programmet og har en speciel kommando til at forlade underrutinen til sidst. Normalt har en underrutine også et navn, som den kan kaldes, selvom en række programmeringssprog også tillader unavngivne underrutiner. I sprog på højt niveau består en underrutinebeskrivelse normalt af mindst to dele: en "header" og en "body". Subrutineheaderen beskriver dens navn og muligvis dens parametre, det vil sige, den indeholder den information, der er nødvendig for at kalde subrutinen. Brødteksten er et sæt af udsagn, der vil blive udført, hver gang subrutinen kaldes.

Et opkald til en underrutine foretages ved hjælp af en opkaldsinstruktion, der inkluderer navnet på underrutinen. I de fleste moderne programmeringssprog er invokationskommandoen simpelthen navnet på den subrutine, der kaldes, eventuelt efterfulgt af faktiske parametre (se nedenfor ).

I det følgende Pascal-eksempel kaldes subprog fra hovedprogrammet tre gange:

program SubProgExample ; // Beskrivelse af underprogrammet subprog procedure subprog ; // Header inklusiv subrutinenavn start // start af subrutinebody WriteLn ( 'Bye' ) ; ende ; // slutningen af underrutineteksten begynder WriteLn ( 'Hej' ) ; subprog ; // 1. kald til subprog ; // 2. opkald subprog ; // 3. opkald afsluttes .

Resultatet af at udføre et sådant program vil være outputtet af strengen "Hej" og de tre strenge "Bye".

For at gemme og gendanne udførelseskonteksten for den kaldende procedure, for at eliminere bivirkninger forbundet med mulige uønskede ændringer i de anvendte maskinregistre, genererer compileren specielle sekvenser af kommandoer for hver procedure, kaldet prologen og epilogen af proceduren.

Nogle programmeringssprog (for eksempel Pascal, Ada, Modula-2) tillader indlejrede underrutiner, det vil sige at placere underrutiner i andre underrutiner. Sådanne indlejrede underrutiner kan kun bruges i den underrutine, hvori de er erklæret. I andre tilfælde (for eksempel på C-sproget) er indlejring af underrutiner ikke tilladt. Indlejring af underrutiner giver ingen grundlæggende fordele, men det kan være praktisk til en mere logisk strukturering af programmet (hvis en eller anden underrutine kun bruges i en anden underrutine, er det logisk at placere den første i den anden).

Underprogramparametre

Tildeling af parametre

Subrutiner bruges ofte til gentagne gange at udføre stereotype handlinger på forskellige data. Subrutinen har normalt adgang til dataobjekterne beskrevet i hovedprogrammet (i hvert fald nogle af dem), så for at overføre behandlede data til subrutinen er det nok at tildele dem for eksempel til globale variabler. Men denne måde er ikke særlig bekvem og fyldt med fejl.

For at sikre den kontrollerede overførsel af parametre til subrutinen og returnering af resultater fra den, bruges parametermekanismen . Parametre er beskrevet i beskrivelsen af subrutinen (i dens overskrift) og kan bruges inde i proceduren på samme måde som variablerne beskrevet i den. Når en procedure kaldes, angives værdierne for hver af parametrene i den kaldende kommando (normalt efter navnet på den kaldte subrutine).

program SubProgExample2 ; // Beskrivelse af underprogrammet subprog procedure subprog ( Linje : String ) ; // Header inklusive underrutinenavn start // start af underrutinelegeme WriteLn ( Linje ) ; ende ; // slutningen af underrutineteksten begynder WriteLn ( 'Hej' ) ; subprog ( 'Farvel,' ) ; // 1. opkald til subprog ( 'min kærlighed,' ) ; // 2. kald til subprog ( 'farvel!' ) ; // 3. opkald afsluttes .

I ovenstående eksempel er linjeparameteren for subprog- underrutinen sat til en anden værdi i hvert opkald, så forskellige linjer vises i stedet for det samme.

Formelle og faktiske parametre

For at skelne parametrene for en underrutine, beskrevet i dens overskrift og brødtekst, fra de parametre, der er angivet, når underrutinen kaldes, bruges formelle og faktiske parametre. Formelle parametre specificeres, når en subrutine deklareres eller defineres, og faktiske parametre angives direkte, når den kaldes. Så i det sidste eksempel er Line- parameteren i headeren og brødteksten af subprog den formelle parameter, og strengen 'Good bye' brugt i det første kald til denne subrutine er den faktiske parameter. Når en subrutine kaldes, bliver de faktiske parametre angivet i opkaldskommandoen værdierne af de tilsvarende formelle parametre, hvilket sikrer overførsel af data til subrutinen.

Sådan overføres parametre til en underrutine

Der er flere måder at overføre parametre til en underrutine.

Overførsel af parametre efter værdi. Den formelle parameter tildeles værdien af den aktuelle parameter. I dette tilfælde vil den formelle parameter indeholde en kopi af den værdi, der er til stede i den faktiske, og enhver effekt, der er lavet inde i subrutinen på de formelle parametre, afspejles ikke i de faktiske parametre. Så hvis en variabel bruges som en faktisk parameter, og værdien af den tilsvarende formelle parameter ændres inde i subrutinen, så vil den faktiske parameter forblive uændret.

int func1(int x) { x=x+2; returnere x; }

Overførsel af parametre ved reference. Selve den aktuelle parameter kan placeres i den formelle parameter (normalt implementeres dette ved at placere en reference til den aktuelle parameter i den formelle parameter). I dette tilfælde vil enhver ændring i den formelle parameter i subrutinen blive afspejlet i den faktiske parameter - begge parametre under opkaldet af subrutinen er de samme. Parametre, der overføres ved reference, gør det muligt ikke kun at sende parametre inde i subrutinen, men også at returnere beregnede værdier til opkaldspunktet. For at gøre dette tildeles parameteren inde i subrutinen simpelthen den ønskede værdi, og ved retur fra subrutinen tildeles den variabel, der bruges som den faktiske parameter, denne værdi.

void func2(int &x) { x=x+2; }

Sender parametre efter navn. Et vilkårligt udtryk kan placeres i en formel parameter. I dette tilfælde vil beregningen af dette udtryk ske inde i subrutinen i det øjeblik, hvor dets værdi er påkrævet. Hvis denne værdi optræder flere gange, vil den også blive beregnet flere gange. Parametre, der sendes ved navn, gør det muligt at skrive ret alsidige underrutiner. Denne metode til at overføre parametre bruges for eksempel på Algol eller Algol 68 sprog .
Sende parametre på stakken. Dette er faktisk en slags parameter, der passerer ved værdien "med manuel kørsel", i dette tilfælde er der ikke noget begreb om formelle og faktiske parametre. Alle parametre ligger på stakken, og deres typer, antal og rækkefølge er ikke kontrolleret af compileren. Denne tilgang er implementeret i det fjerde sprog .

Et programmeringssprog kan give mulighed for at videregive parametre til underrutiner enten kun efter værdi, eller efter værdi og ved reference, eller ved navn og værdi. I de sidste to tilfælde bruges separate syntaktiske konstruktioner til at skelne mellem måderne at sende en parameter på (i Pascal er dette nøgleordet var , når man beskriver en parameter). Faktisk, hvis sproget indeholder begrebet et link (pointer), så kan du undvære at sende en parameter ved reference (det kan altid modelleres ved at beskrive en parameter af typen "reference"), men denne funktion er praktisk, da det giver dig mulighed for at arbejde med en formel parameter-reference uden dereference , og øger også pålideligheden og sikkerheden af programmet.

Naturlige restriktioner pålægges parametre, der sendes ved reference: den faktiske parameter, der erstattes af en sådan parameter, når den kaldes, skal være en variabel (det vil sige have en adresse), og i stærkt indtastede sprog skal den også have nøjagtig den samme datatype.

Typer af underrutiner

Der er to typer underrutiner, der bruges i programmeringssprog på højt niveau: procedurer og funktioner .

En funktion er en underrutine af en særlig art, som udover at modtage parametre, udføre handlinger og sende resultaterne af arbejdet gennem parametre, har endnu en funktion - den skal altid returnere et resultat. Et funktionskald er fra programmeringssprogets synspunkt et udtryk, det kan bruges i andre udtryk eller som højre side af en opgave.
En procedure er en uafhængig navngivet del af et program, der, efter at være blevet beskrevet én gang, gentagne gange kan kaldes ved navn fra efterfølgende dele af programmet for at udføre bestemte handlinger.

I C -lignende sprog beskrives en subrutine altid som en funktion. Proceduren er implementeret som en funktion af typen void , det vil sige, den har en "tom" type og returnerer derfor ingen værdi.

Subrutiner, der er en del af klasser i objektprogrammeringssprog, kaldes normalt metoder . Dette udtryk refererer til ethvert medlems underprogrammer i en klasse, både funktioner og procedurer; når der kræves afklaring, taler man om metoder-procedurer eller metode-funktioner .