Ugrás a tartalomhoz

procedural programming

A Wikiszótárból, a nyitott szótárból

Angol


Főnév

procedural programming (tsz. procedural programmings)

  1. (informatika) A procedurális programozás (más néven eljárásorientált programozás) az egyik legősibb és legelterjedtebb programozási paradigma. A lényege, hogy a programot függvényekre (eljárásokra) bontjuk, és a program végrehajtása ezen függvények hívásán keresztül történik.

Alapfogalmak

  • Függvény: Olyan kódrészlet, amely meghatározott bemeneteket (paramétereket) fogad, és egy adott feladatot végez el. Lehet visszatérési értéke, de lehet „void” típusú, ha nem tér vissza semmivel.
  • Változó: Egy névhez kötött memóriahely, amely adatot tárol.
  • Állapot: A változók pillanatnyi értékei a program végrehajtása során.
  • Vezérlési szerkezetek: if-else, while, for, switch stb., melyek irányítják a program futását.

Jellemzők

  • A program középpontjában a függvények és az adatok állnak.
  • Az adatokat általában globális vagy lokális változóként kezeljük, és a függvények módosítják őket.
  • A nagyobb programot kisebb feladatokra bontjuk, amelyeket külön-külön, jól definiált függvényekben valósítunk meg.


Függvények deklarálása és definiálása

C++ nyelvben a függvényt először deklaráljuk, majd definiáljuk:

Példa:

#include <iostream>
using namespace std;

void koszont(); // deklaráció

int main() {
    koszont(); // függvényhívás
    return 0;
}

void koszont() { // definíció
    cout << "Hello, vilag!" << endl;
}

Paraméterátadás

Kétféle alapvető paraméterátadás: - Érték szerint: az eredeti változó értéke másolódik a függvénybe. - Referencia szerint: a függvény közvetlenül az eredeti változót éri el.

Példa érték szerinti átadásra:

void duplaz(int szam) {
    szam *= 2;
}

int main() {
    int ertek = 5;
    duplaz(ertek);
    cout << ertek; // továbbra is 5
}

Példa referencia szerinti átadásra:

void duplaz(int &szam) {
    szam *= 2;
}

int main() {
    int ertek = 5;
    duplaz(ertek);
    cout << ertek; // 10
}

Adattípusok és változók

A procedurális C++-ban alapvető adattípusokat használunk:
- int: egész számok
- double, float: lebegőpontos számok
- char: karakterek
- bool: logikai érték
- string (a <string> könyvtárral): szövegek


Vezérlési szerkezetek

  • if-else: elágazás
if (feltetel) {
    // ha igaz
} else {
    // ha hamis
}
  • while: amíg ciklus
while (feltetel) {
    // ismétlődik
}
  • for: ciklus ismert lépésszámmal
for (int i = 0; i < 10; i++) {
    cout << i << endl;
}
  • switch-case: több lehetséges ágon futó elágazás
int nap = 3;
switch (nap) {
    case 1: cout << "Hetfo"; break;
    case 2: cout << "Kedd"; break;
    case 3: cout << "Szerda"; break;
    default: cout << "Ismeretlen";
}

Tömbök

A procedurális programozásban gyakran használunk tömböket:

int szamok[5] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {
    cout << szamok[i] << endl;
}

Tömb átadása függvénynek:

void kiir(int tomb[], int meret) {
    for (int i = 0; i < meret; i++)
        cout << tomb[i] << " ";
}

int main() {
    int t[3] = {10, 20, 30};
    kiir(t, 3);
}

Ciklusok kombinációja és beágyazott ciklusok

Gyakori eljárás beágyazott ciklusokat használni:

for (int i = 0; i < 3; i++) {
    for (int j = 0; j < 3; j++) {
        cout << "(" << i << "," << j << ") ";
    }
    cout << endl;
}

Fájlkezelés procedurális módon

C++-ban az fstream könyvtárat használjuk:

#include <fstream>
using namespace std;

int main() {
    ofstream ki("adatok.txt");
    ki << "Hello fajlba!" << endl;
    ki.close();

    ifstream be("adatok.txt");
    string sor;
    while (getline(be, sor)) {
        cout << sor << endl;
    }
    be.close();
}

Gyakorlati példa: Összegzés függvénnyel

int osszeg(int tomb[], int meret) {
    int ossz = 0;
    for (int i = 0; i < meret; i++)
        ossz += tomb[i];
    return ossz;
}

int main() {
    int szamok[] = {2, 4, 6, 8};
    cout << "Osszeg: " << osszeg(szamok, 4) << endl;
}

Függvények szervezése

Ha hosszabb kódot írunk, célszerű a függvények deklarációját a main() elé tenni, definíciójukat utána.
Például:

int osszeg(int tomb[], int meret);

int main() {
    int szamok[] = {1, 2, 3, 4, 5};
    cout << "Osszeg: " << osszeg(szamok, 5);
}

int osszeg(int tomb[], int meret) {
    int ossz = 0;
    for (int i = 0; i < meret; i++)
        ossz += tomb[i];
    return ossz;
}

Tiszta (pure) procedurális szemlélet vs. objektumorientált

  • A tiszta procedurális programozás során a függvények és adatok teljesen elkülönülnek.
  • A C++ lehetővé teszi az objektumorientált programozást is, de procedurális szemléletben ezzel nem foglalkozunk.
  • Előnye: átláthatóság, egyszerűség, gyorsan átlátható és tanulható.
  • Hátránya: nagy rendszerekben nehezen karbantartható, a globális változók miatt bonyolulttá válhat.


Összefoglalás

A procedurális programozás C++-ban nagyon hatékony, ha: - jól bontjuk fel a feladatokat kisebb egységekre, - függvényeket tisztán, önállóan írunk, - minimalizáljuk a globális változók használatát, - átlátható ciklusokat és elágazásokat alkalmazunk.

A procedurális szemlélet ideális alap a programozás megtanulásához, és minden komplexebb (például objektumorientált) paradigma alapja.


További információk

A lap eredeti címe: „https://hu.wiktionary.org/w/index.php?title=procedural_programming&oldid=3491125”