Az adatok feldolgozása , a rutin egy adat feldolgozására egység , amely magában egy részét kódot (a szekvenciát az utasításokat ) végrehajtunk egy jól azonosított speciális feldolgozási (menesztőbordák, feladat, számítás, stb) viszonylag független a többi a program, és a amelyek felhasználhatók ugyanabban a programban, vagy egy másik programban. Ebben az esetben a rutint gyakran egy könyvtárban tárolják, hogy elérhetővé tegyék más programozási projektek számára, megőrizve a megvalósítás integritását.
A rutinok lehetővé teszik a probléma felosztását az elvégzendő program bontásával olyan kóddarabokra, amelyeket könnyebb előállítani, használni, kezelni és karbantartani. A rutint végrehajtó utasítások benne vannak, és a programozó felhívhatja a rutint anélkül, hogy aggódna ennek a belső részletei miatt; a rutin fekete doboz szerepét tölti be az azt használó rutinokban.
A számítógépes programozásban a rutinokat két fő formában találjuk meg:
| az eljárás | Egy rutin, amely semmilyen értéket nem ad vissza, jól meghatározott műveletet (feladatot) hajt végre, amelynek használata ad-hoc utasítás szerepét tölti be . |
| funkció | Olyan rutin, amely egy és csak egy értéket ad vissza, a függvény matematikai meghatározása szerint . |
A rutin csak akkor hatékony, ha legalább egy értéket ad vissza a hívó rutinnak, vagy (beleértve), ha hatással van a környezetére ( érzékelő olvasása , írás az aktuátornak , egy globális változó megváltoztatása stb.).
| előre meghatározott rutin | Olyan rutin biztosított, leggyakrabban egy könyvtárban , amelyet definiálás nélkül lehet használni, ha ismerjük annak deklarációját és szerepét. |
| dummy rutin | Olyan rutin, amely a program fejlesztése során ideiglenesen nem csinál semmit (a rutin törzse üres). |
| Módszer | Egy osztály rutinja ( objektum-orientált programozásban ) |
A legtöbb programozási nyelvek , a nyilatkozat (és ezért a definíció) rutin általában tartalmazza:
Funkció esetén a rutin deklarációja a következőket is tartalmazza:
Bizonyos programozási nyelvekben , amelyek ezt lehetővé teszik, ami ma (2016) ritka, megadják az egyes paraméterekhez társított cseremódot:
Ezek az elemek nem feltétlenül jelennek meg az összes programozási nyelven .
A rutin aláírása (profilja) vagy névdekoráció lehetővé teszi a fordító ( fordító , tolmács stb.) Számára , hogy ellenőrizze, hogy a rutint a deklarációjával összhangban használják-e. Lehetővé teszi azt is, hogy a linker (linker) létrehozza a kapcsolatot a megfelelő rutinnal.
Az aláírás általában a következőket használja:
A programozási nyelvek jelenlegi (2013) megvalósításakor a hívó rutinból származó argumentumok másolata a hívott rutin (meghívott rutin) paramétereibe kerül , ahelyett, hogy a hívó rutin tényleges változóin dolgozna, ami nem mindig igaz az 1960-as években (például a FORTRAN IV-ben).
Mindazonáltal mindig lehet dolgozni a valódi változókon, ha ezeket „globálisnak” nyilvánították, de ez veszélyforrás és nem „hordozható”. Ezt azután nevezik szegélyhatást .
A rutinok azonban gyakran a rutinváltozók (argumentumok) hívásának memória címét kérik, nem pedig az értékeiket. Ez a mechanizmus használ mutatót (vagy egy referencia , a C ++ , Perl vagy PHP ). Normális esetben a modularitás érdekében a rutin nem ad vissza értéket a hívó rutin (argumentumok) változóinak módosításával. Például Fortranban ezt szigorúan tiltják a nyelvi előírások, és a fordítók észlelik. A függvény egyetlen eredményt adhat vissza visszatérési értékével. Ez az eredmény többek között a következő lehet:
A rutin teste a következőket tartalmazza:
Vagy három számot írunk növekvő sorrendben, például:
| Kódolt | Magyarázat |
|---|---|
| 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;
|
A matematikához hasonlóan az itt definiált min és max függvények :
A maximális rutin :
|
|
//********************************************
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;
|
A classETsort eljárás (vagy művelet) :
|
|
//******************************************** 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.
|
A program fő rutinja:
Az olvasás (a fő rutinban) és az írás (a classETsort rutinban ) feltételezhetően előre definiált; |
| int max ( int a, int b ) { return a > b ? a : b; } | A függvény maxparaméterekkel aés begész számmal ( int) rendelkezik, és egy egész értéket ad vissza ( int).
A nadrágtartók {és }körülhatárolják a tulajdonság testét. A függvény neve ( max) leírja az általa végrehajtott műveletet; aés a közötti legnagyobb értéket adja vissza b. Ez nem a nyelv kötelessége, hanem jó programozási gyakorlatot jelent: a függvény neve csak emlékeztető jelentőségű, viselkedése csak a testében található utasításoktól függ. Egyes nyelvekben a függvény neve különös jelentőséggel bír. Például a C ++ - ban a konstruktorokat és a destruktorokat a megfelelő osztályról kell elnevezni. |
| int main ( int argc, char *argv[] ) { //... printf ( "La valeur maximum est %i.\n", max(123,456) ); //... return 0; } | A fő funkció ( main) függvényt használja max(az úgynevezett „funkció hívás”) függvény argumentum printf : max(123, 456). |
Nem minden programozási nyelv valósítja meg a rutinok mindkét formáját. A két rutinformát megvalósító nyelvek kulcsszót tartanak fenn, hogy megkülönböztessék őket a nyilatkozat során.
| Nyelv | Eljárás | Funkció |
|---|---|---|
| Selypít | A funkció speciális esete | defun |
| C , C ++ | A funkció különleges esete: a visszatérés speciális típusa void | Nincs kulcsszó |
| Pascal | PROCEDURE | FUNCTION |
| Fortran | subroutine | function |
| Algol | procedure | Az eljárás különleges esete |
Egyes programozási nyelveknél a két fogalom közel áll egymáshoz, a megkülönböztetés csak abban az esetben történik, ha visszaadunk egy értéket, vagy nem, vagy ha egy eljárás többféle eredménnyel történik, vagy ha egy függvény bemeneti műveleteket végez.
Másrészt azoknál a nyelveknél, amelyek az eljárások mellett csak tiszta funkciókat fogadnak el , a két fogalom nagyon megkülönböztethető.
Például a C / C ++ - ban vagy a Lisp-ben az összes rutin függvény; ezért a nyelvi dokumentáció csak a funkcióról beszél. Másrészről, annak érdekében, hogy az eljárás egyenértékű legyen, és hogy az eljárásokkal rendelkező nyelveken írt programokat könnyen konvertálhassuk, a C / C ++ nyelvi nyelv megadja azt a típust, voidamely lehetővé teszi a semmit nem adó függvény deklarálását, ezáltal eljárást végez.
A C / C ++ esetén bizonyos funkciók visszatérési értékét, mint például printf()(írjon a stdout kimeneti adatfolyamnak) vagy scanf()(olvassa el a stdin bemeneti adatfolyamnak), amelyek jelentik a végrehajtásukat, gyakrabban figyelmen kívül hagyja az azt használó rutin; ezért lényegében nyomozói szerepet töltenek be, mint egy eljárás.
Az Algol W alkalmazásban bármely rutin olyan értéket ad vissza, amelyet használhatunk vagy sem, ami hasonló a C nyelv megközelítéséhez.
A PL / I csak olyan eljárást tekint függvényként, amelynek eredménye nincs memorizálva, amely szintén hasonlít a C nyelvi megközelítésre, másrészt az olyan nyelvek, mint a Fortran , Algol 60 , BASIC , Pascal , Modula 2, egyértelműen megkülönböztetik mindkét fogalmat kulcsszavakkal .
| Nyilatkozat | Meghatározás | |
|---|---|---|
| Funkció | int somme(int var1, int var2); | int somme(int var1, int var2) { return var1 + var2; } |
| Eljárás | void afficher(int var); | void afficher (int var) { printf ("Valeur = %i\n", var) ; return; } |
Wirth N., Algoritmusok és adatszerkezetek , Eyrolles, 1980, trad. de Algoritmusok + adatszerkezetek = Programok , 1976, Prentice-Hall sorozat az automatikus számításban.