procedural programming

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.

• 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.

• 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.

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;
}

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
}

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

• 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";
}

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

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

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

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

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

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;
}

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();
}

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

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

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;
    return ossz;
}

• 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.

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.

• procedural programming - Szótár.net (en-hu)
• procedural programming - Sztaki (en-hu)
• procedural programming - Merriam–Webster
• procedural programming - Cambridge
• procedural programming - WordNet
• procedural programming - Яндекс (en-ru)
• procedural programming - Google (en-hu)
• procedural programming - Wikidata
• procedural programming - Wikipédia (angol)