Ebben a tananyagban programozással kapcsolatos fogalmak, definíciók szerepelnek viszonylag tömören, többnyire példák nélkül. Ha valaki soha nem látott programkódokat, példaprogramokat, annak a számára ezeket a fogalmakat, definíciókat jó eséllyel nehéz lesz megérteni, de akinek már van némi fogalma a programozásról, annak talán jól jöhet egy ilyen fogalomtár.
Például nem biztos, hogy valaki tudja, hogy a default konstruktor a 0 paraméteres konstruktor, vagy az a konstruktor, ami automatikusan létrejön, ha nem definiálunk konstruktort.
Ez a fogalomtár esetleg vizsgák, zh-k elméleti kérdéseket tartalmazó részéhez is jól jöhet.

Sajnos a fogalmakat nehéz egymásra épülően leírni, mivel a programozásban jellemzően egy hamarabb tárgyalt fogalom összefügghet egy később tárgyalt fogalommal. Például az utasítás vagy kifejezés két legalapabb fogalom a programozásban, de amíg nem vettük a logikai típusokat, addig nem biztos, hogy érthető lesz valaki számára, hogy egy logikai kifejezés mit jelent.

Az itt leírt fogalmak imperatív programozási nyelvekre (pl. nem funkcionális programozási nyelvekre) vonatkoznak. A legtöbb ember, aki programozásra adja a fejét, imperatív programozási nyelvekkel találkozik először.
Ilyen nyelvek pl. C, C++, C#, Java, Basic, Pascal, Ada, Javascript, Python, Perl.
Nem ilyen nyelvek pl. Haskell, Clean, O'Caml, F#.

Vannak olyan tananyagaim, amikben példákon keresztül magyarázom el a programozás alapvető fogalmait, például:

• itkezdoknek.blog.hu, programozási alapfogalmak, C++, Javascript példák
• itkezdoknek.blog.hu, cpp, első tananyagrész

plain text fájl

Olyan fájl, ami nem tartalmaz formázást (pl. nem lehet benne a szöveg egyes részeire vonatkozó betűtípust vagy szövegméretet beállítani, nincs benne élőfej, élőláb, és hasonlók).

A plain text fájlra jó példa a txt kiterjesztésű/formátumú fájlok.

Amikor programozunk, minden esetben plain text fájlokban dolgozunk, csak nem txt kiterjesztést használunk, hanem pl. C++ esetén cpp-t vagy h-t, webfejlesztés esetén html-t, css-t, js-t, php-t, satöbbi.

A plain text fájlok ellentétei például a pdf, doc, docx fájlok, amiket jellemzően dokumentumszerkesztővel (Microsoft Word, LibreOffice Writer) szerkesztünk.

text editor

Olyan program, ami plain text fájlok szerkesztésére alkalmas. Windowsban például jegyzettömb (notepad.exe), Linuxon például gedit, Kate, FeatherPad.

code editor

Olyan program, amit plain text fájlok szerkesztésére használhatunk, de vannak benne programozást segítő funkciók.

Programozást segítő funkciókra néhány példa:

• a kódban szereplő hibák jelzése
• kódszínezés
• kódkiegészítés (ha pl. beírunk egy kódban szereplő kulcsszót félig, akkor a code editor mutatja a teljes szót, esetleg bizonyos billentyűkombinációval ki is egészíti)

Példák code editorokra:

• Visual Studio Code
• Notepad++ (csak Windows)
• Sublime Text
• Atom
• Brackets
• Emacs
• Linuxon parancssorban: nano, pico, joe, mcedit, vi

IDE (integrated development environment)

Első ránézésre code editorra hasonlít, de sokkal több programozást segítő funkció van benne, mint egy code editorban. Például elő tud állítani futtatható programot a forráskódból, több fájlt úgynevezett projektekben tud kezelni, több hibát tud jelezni mint egy code editor, vannak benne teszteléshez, hibajavításhoz (úgynevett debuggoláshoz) használható funkciók.

Néhány példa IDE-re:

• Microsoft Visual Studio (sok nyelv)
• Eclipse (Java)
• Netbeans (Java, php)
• CodeBlocks (C, C++)

forráskód

Egy program működését meghatározó utasítások összessége.

forrásfájl

Egy program forráskódját tartalmazó fájl. Egy programnak több forrásfájlja is lehet.

nyílt forráskódú (open-source) programok

Azon programok, amelyeknek a forráskódját a program készítői a felhasználók számára elérhetővé teszik.

szintaxis

Egy adott programozási nyelv "nyelvtani" szabályainak összessége.

Például:

• az utasítások végére pontosvesszőt kell tenni
• for ciklusban a paramétereket pontosvesszővel kell elválasztani
• egy változó neve nem kezdődhet számmal, és nem egyezhet meg a nyelvben szereplő kulcsszavak egyikével sem

Különböző programozási nyelveknek jellemzően különböző szintaxisa van, de bizonyos programozási nyelvek szintaxisa hasonlít egymásra.

Hogyan lesz egy forrásfájlból futtatható program?

fordított nyelvek

Pl. C, C++, Pascal, Ada esetén egy úgynevezett fordító (compiler) program hozza létre a forrásfájlokból a futtatható program futtatható fájljait. A futtatható program futtatásához nincs szükség a fordítóra.

A futtatható program fájljaiból nem, vagy csak nagyon nehezen lehet előállítani a forrásfájlokat (ha azok nincsenek meg). Reverse engineeringnek nevezik a futtatható fájlokból a forrásfájlok visszafejtését.

értelmezett nyelvek

Jellemzően script nyelvek, pl Python, Perl, Bash Script, esetén egy értelmező (interpreter) a forráskódot sorról-sorra futtatja, de nem hoz létre belőle futtatható programfájlt.

köztes kód (bájtkód)

Java, C# esetén a fordító olyan futtatható fájlt hoz létre, aminek a futtatásához szükség van valamilyen segédprogramra, például Java esetén JVM (Java Virtual Machine)-ra, C# esetén dotnet frameworkre.

transpiler

Vannak olyan nyelvek, amiknek a kódját egy úgynevezett transpiler átalakít egy más nyelv kódjára. Például a Typescript kódot egy transpiler alakítja át Javascript kóddá, vagy például régen a C++ nyelv kódját egy transpiler átalakította C nyelvű kódra és a C nyelv fordítója hozta létre belőlük a futtatható programot.

webfejlesztés

html, css, javascript (kliens oldali, frontend fejlesztés)

A html fájlok dupla kattintással megnyithatók böngészővel, vagy ha feltöltjük őket webszerverre, akkor alapbeállítás szerint az index.html tartalma fog látszódni az oldal betöltődésekor. A css, javascript fájlokat vagy hozzákapcsoljuk a html fájlokhoz, vagy pedig a tartalmukat beleírjuk a html fájlokba.

php, nodejs, szerver oldali (backend) fejlesztés

Ezeknek a fájloknak a weboldallá alakított változatát a saját számítógépünkön csak valamilyen segédprogrammal (pl. xampp vagy visual studio code esetén live server kiegészítő) tudjuk előállítani.
De ha feltöltjük őket webszerverre, akkor nem kellenek hozzájuk ilyen segédprogramok, hanem pl. alapbeállítás szerint az index.php tartalma fog megjelenni az oldal betöltődésekor.

belső linkek

Egy weboldal általában több fájlból áll (pl. kezdőlap, hírek, képtár, rólunk), amiket belső linkekkel kapcsolunk össze. Ezek jellemzően <a></a> html tagek.

Szintaktikai hiba (syntax error)

Egy programozási nyelv szabályai egyikének nem betartása a forráskód írásakor. Az oka gyakran elgépelés.

Szemantikai hiba

Egy program logikai működéséből adódó hiba, vagyis amikor egy program lehet, hogy lefut, de nem pontosan azt csinálja amit szeretnénk.

Adatok a programjainkban

Egy program adatokkal dolgozik, adatokból adatokat állít elő (jellemzően nem egy lépésben, hanem utasítások sorozatával, köztes eredményeket létrehozva).
Azok az adatok, amikkel a programunk dolgozik, a számítógép memóriájában (RAM) vannak tárolva, és a számítógép kikapcsolásakor elvesznek.

Honnan vesz egy program adatokat?

• a felhasználótól kéri be
• fájlból olvassa be (akár adatbázisból, hálózatról kérdezi le)
• egy másik program kimenetét (eredményét) használja fel
• a programozó beleír a kódba egy konkrét adatot (pl. a program verziószámát)
• bizonyos utasításokkal random generált értékeket (pl. random generált számokat) állít elő
• a programban már szereplő adatokból bizonyos utasításokkal, műveletekkel új adatokat állít elő

Hogyan tárol egy program adatokat?

• változó (variable): a program futásának egy pillanatában egyetlen adat tárolható benne
• tömb (array): a program futásának egy adott pillanatában több (jellemzően azonos típusú) adat tárolható benne
• objektum (object): a program futásának egy adott pillanatában több (jellemzően különböző típusú adat tárolható benne, hasonló egy adatbázis rekordjához (pl. név, email cím, telefonszám, születési dátum)

Alaptípusú változók (fundamental types), beépített típusú változók (builtin types), egyszerű típusú változók (primitive/basic types)

Jellemzően ezek:

• integer, egész szám
• float, double, valós szám
• char, karakter
• string, szöveg, több karakter, karakterlánc
• bool, boolean, igaz/hamis érték

Ellenpélda mondjuk a dátum és bizonyos programozási nyelvekben a string.

A három fogalom (alaptípus, beépített típus, egyszerű típus) nagyjából ugyanazt jelenti, de azért ebben vannak programozási nyelvekben eltérések. Jellemzően ez a jelentésük:

• olyan típusok, amik alapból elérhetőek az adott programozási nyelvben, nem kell hozzájuk bizonyos fájlok tartalmát a kódunkba illeszteni, ahhoz, hogy használni tudjuk őket (pl. C++ esetén a string használatához szükség van az utóbbira)
• a program futásának egy adott pillanatában szigorúan egy értéket tartalmazhatnak (több értéknek számíthat például a string, mert az több karakterből állhat)

De például Javascriptben nincs karakter típus, és a string alaptípusnak számít (annak ellenére, hogy a string a háttérben valójában egyszerre több karakter). Sőt, Javascriptben nincs külön egész szám és valós szám típus, csak szám típus létezik.

Definíció, deklaráció

A legtöbb programnyelvben, ha adatokat szeretnénk tárolni, kezelni, akkor azt a kódban jeleznünk kell. Ezt magyarul sokszor úgy mondjuk, hogy létrehozunk egy változót.

Ellenpélda például a PHP nyelv, abban ha leírjuk egy változó nevét, akkor az a változó automatikusan létrejön.

Nem csak adatoknak van definíciója, hanem pl. függvényeknek is, de arról majd később.

Változó értéke

Az az adat, amit egy változóban a program futásának egy adott pillanatában tárolunk.

Változó neve

Egy változóra, illetve a benne tárolt értékre a változó nevével hivatkozunk.

Egy változó elnevezésének vannak szabályai, például:

• itkezdoknek.blog.hu, cpp, variable naming rules

Egy változó elnevezésére vannak bizonyos szokások, amik programnyelvenként, vagy cégenként, munkahelyenként eltérőek lehetnek:

• itkezdoknek.blog.hu, változók elnevezései

Azonosító, identifier

Nem csak a változóknak van neve, hanem például tömböknek, osztályoknak, objektumoknak, függvényeknek. Ezeket összefoglaló néven identifiernek, azonosítónak nevezzük.

Változó típusa

Erősen típusos, statikusan típusos nyelvekben a változók típusát a változó létrehozásakor meg kell adni, és az nem változhat meg a változó létezéséig vagy akár a program futásának végéig.

Gyengén típusos, dinamikusan típusos nyelvekben a változók típusát a bennük tárol adat típusa határozza meg, és egy változó típusa a program futása során megváltoztatható.

Változó inicializálása (kezdőértékadás):

Amikor egy változónak a változó létrehozásával egy utasításban értéket adunk.

Értékadás (assignment):

Amikor egy már definiált változónak új értéket adunk (akár a régi értékének a felhasználásával, pl. egy szám típusú változóhoz hozzáadunk 5-öt).

Inkrementálás:

Egy szám típusú változó értékét megnöveljük 1-el.

Konstans, konstans változó:

Olyan változó, aminek az értéke a program futása során nem változhat meg, vagyis a változó létezéséig, vagy a program futásának a végéig a változó kezdőértéke marad. A konstansoknak kötelező kezdőértéket adni.

Literál

A kódba beleírt konkrét érték. Természetesen ezek is különböző típusúak lehetnek. Például stringliterál.

Típusminősítő (type qualifier)

Például konstans változók esetén a const kulcsszó.

Típusmódosító (type modifier)

Például C, C++ nyelvekben szám típusú változókból használhatunk olyanokat, amik kevesebb helyet foglalnak a memóriában de az értéktartományuk kisebb, illetve olyanokat, amik több helyet foglalnak a memóriában, de az értéktartományuk nagyobb. Ennek akkor lehet értelme, ha például egy függvényt nagyon sokszor futtatunk és a függvény minden egyes futásakor létrehozunk a függvényben változókat.

Példák:

• short
• long
• long long

Implementációfüggő

Ha egy programnyelv szabályai függhetnek a fordító típusától, illetve a számítógép típusától. Például a C, C++ nyelvek használhatóak mikrokontrollerek, szuperszámítógépek vagy átlagos számítógépek programozásához, és például az alaptípusú változók mérete (hogy mennyi helyet foglalnak a számítógép vagy eszköz memóriájában) eltérő lehet különböző rendszereken.

Explicit típuskonverzió

Amikor egy értéket vagy egy kifejezés eredményét a programkódban egy adott kulcsszóval, utasítással vagy kifejezéssel más típusúvá konvertálunk.

Pl. a !!"" kifejezés Javascriptben azt jelenti, hogy egy üres stringet (0 karaktert tartalmazó stringet) logikai értékké konvertálunk.

Implicit típuskonverzió

Amikor egy utasításban más típusú kifejezést írunk olyan helyre, ahol nem olyan típusú kifejezés elvárt.

Például mondjuk ha egy egész szám típusú változónak értékül adunk egy valós szám típusú változó értékét.

Vagy például ha egy elágazásban a feltétel helyett nem logikai kifejezést adunk meg.

Kiíratás

Amikor a program kimeneteként megadunk, vagyis egy kiírató utasítással kiíratunk egy változó értékét, tömb elemét, elemeit, objektum adattagját, adattagjait, kifejezést, vagy literált.

Például a legelső példaprogramban általában egy hello world stringliterált íratunk ki.

Bekérés

Amikor a program bekér valamilyen értéket a felhasználótól és azt jellemzően egy változó értékeként tárolja el, vagy például elvégez vele egy műveletet és a művelet eredményét kiírja a program.

Vezérlési szerkezet

Szekvencia, elágazás, ciklus gyűjtőneve.

Szekvencia

Egymás után írt utasítások, amik a program futása során egymást követően futnak le.

Elágazás

Ha egy feltétel (jellemzően logikai kifejezés) teljesül, akkor különböző utasítást vagy utasítássorozatot hajt végre a program, mint amikor a feltétel nem teljesül.

Az elágazásokat egymásba is lehet ágyazni, vagyis több feltételt is meg lehet adni.

Az is elágazásnak számít, ha csak akkor hajt végre a program utasításokat, ha a feltétel teljesül, ha pedig nem teljesül, akkor nem hajt végre utasításokat a program.

Azokat az utasításokat, amik akkor futnak le, ha a feltétel igaz, összefoglaló néven if ágnak nevezzük, esetleg az elágazás if blokkjának, azokat az utasításokat, amik akkor futnak le, ha a feltétel hamis, azokat pedig else ágnak nevezzük.

Logikai kifejezések

Olyan kifejezések, amiknek az értéke logikai (igaz/hamis) értékre értékelődik ki. Például ha összehasonlítunk egy két számot, hogy melyik nagyobb, vagy például ha egy string karakterszámáról állapítjuk meg, hogy kisebb-e vagy nagyobb-e vagy egyenlő-e egy bizonyos számértéknél.

Tuthy, falsy értékek

Ha egy nem logikai értéket, kifejezést logikai értékké konvertálunk, akkor igaz (truthy) vagy hamis (falsy) lesz az értéke. Általában 0 és 0-val egyenértékű értékek konvertálódnak hamissá, de például az üres string (0 karaktert tartalmazó string) C++-ban igazzá konvertálódik, Javascriptben pedig hamissá, szóval az, hogy mik a truthy és falsy értékek az programozási nyelvenként eltérő lehet.

Tömb indexe

Arról már volt szó, hogy egy tömbben a program futásának egy adott pillanatában több érték tárolható. De a tömb főként abban különbözik a változótól, hogy csak egy neve van, és a benne tárolt értékekre a tömb nevével és egy számmal hivatkozunk. Ezt a számot hívjuk indexnek. A tömb első elemének indexe 0, az utolsó elemének az indexe pedig a tömb elemszámánál eggyel kisebb szám.

Tömb mérete

Ahány elem van a tömbben, vagyis a tömb elemszáma.

Bizonyos programozási nyelvekben (pl. C, C++, Java) léteznek olyan tömbök, amelyeknek a mérete nem változtatható.

Bizonyos programozási nyelvekben (pl. C, C++) léteznek olyan tömbök, amelyeknek az elemszámát külön kell tárolnunk egy változóban, vagyis a tömb nem tudja magáról az elemszámát, nem kérdezhető le a tömb egy segédfüggvényével vagy adattagjával a tömb elemszáma.

Ciklus

Egy utasítás vagy utasítássorozat ismételt végrehajtása addig, amíg egy feltétel teljesül.

for ciklus

Olyan ciklus, aminél jellemzően megállapítható a programkód írásakor, hogy hányszor fog lefutni.

A for ciklussal jellemzően tömböket járunk be (pl. kiíratjuk vagy módosítjuk egy tömb értékeit). Ekkor nyilvánvalóan annyiszor fog lefutni a ciklus, ahány eleme van a tömbnek.

A for ciklusban fordítva is bejárhatjuk a tömböt, vagy például megcsinálhatjuk azt is, hogy a tömbnek csak minden második elemét járjuk be.

foreach ciklus vagy ranged for ciklus

A for ciklus egy speciális változata ami kifejezetten tömbök, tömbszerű adatszerkezetek bejárására lett kiélezve. Ezzel a ciklussal egy tömböt csak az első elemétől jellemzően az utolsó eleméig tudunk bejárni. Esetleg a ciklus megszakítható break utasítással (pl. ha keresünk egy tömbben egy elemet, és nem a tömb utolsó elemeként találtuk meg, akkor a ciklusnak fölösleges tovább futnia).

while ciklus

Olyan ciklus, amely esetén jellemzően nem állapítható meg a programkód írásakor, hogy a ciklus hányszor fog lefutni.

Például ha egy olyan fájl sorait olvassuk be, amelyik fájlról tudjuk, hogy a sorszáma változik (pl. akár a felhasználó ír bele bizonyos időközönként különböző sorszámú dolgokat, vagy akár egy másik program).

do-while ciklus

Egy olyan ciklus aminek az utasításai egyszer mindenképp lefutnak.

Jellemzően adatellenőrzésre vagy utasítások újrafuttatásának megkérdezésére használjuk.

Adatellenőrzés esetén például logikus, hogy ahhoz, hogy mondjuk egy számról el tudjuk dönteni, hogy negatív-e, legalább egyszer be kell kérnünk a felhasználótól vagy be kell olvasnunk fájlból.

ciklusmag

Azok az utasítások, amiket a ciklus lefuttat (amíg a ciklusfeltétel igaz). A ciklusmagot a ciklus blokkjának is nevezhetjük.

Elfedés (shadowing)

Ha egy blokkban, például elágazás vagy ciklus blokkjában létrehozunk egy olyan változót, aminek a neve azonos a ciklus blokkján kívül létrehozott változóval, akkor a ciklus blokkján kívül létrehozott változóra nem fogunk tudni hivatkozni, nem fogunk tudni hozzáférni.

Függvény (function)

A programozásban egy függvény működését alapvetően úgy képzelhetjük el, hogy megadunk egy vagy több utasítást, adunk a függvénynek egy nevet, és a programkód későbbi pontjain ha a függvény nevét leírjuk, akkor ott lefut ez az utasítássorozat.
Ez azért is jó, mert ha az utasítássorozatban módosítanunk kell valamit, azt elég a függvényben módosítani (azzal szemben mintha az utasítássorozatot ismételten leírnánk a programkód különböző pontjain), illetve azért is jó, mert részfeladatokra bontja a forráskódot.

Fontos viszont, hogy egy függvénynek lehetnek bemenő értékei (úgynevezett paraméterek), illetve lehet kimenő értéke (úgynevezett visszatérési érték).
A függvény, mint fogalom sokszor úgy van leírva a programozásban, hogy bizonyos bemenő értékekből előállít egy kimenő értéket.

Viszont léteznek olyan függvények, amiknek nincs visszatérési értéke. Bár technikailag ezeknek is kell, hogy legyen valami kimenete (például egy bemenő paraméter értékét változtatják meg, vagy kiíratással írnak ki egy értéket), de egy ilyen függvény futtatásának (úgynevezett függvényhívásnak) a helyére nem ad vissza értéket. Ezeket a függvényeket bizonyos programnyelvekben eljárásoknak (procedure) nevezzük, bizonyos programnyelvben pedig void visszatérési típusú függvényeknek.

Függvénydefiníció

Amikor jelezzük a programkódban, hogy egy függvényt a programkód további részeiben használni szeretnénk, vagyis amikor létrehozunk egy függvényt. Ez jellemzően abból áll, hogy megadjuk a függvény visszatérési típusát, a függvény nevét, a bemenő paramétereit, illetve az utasításokat, amiket a függvény lefuttat, illetve ha van, akkor a visszatérési értékét (ezt általában return kulcsszó után).

Függvényhívás (function call)

Amikor futtatjuk a függvényt, vagyis amikor a függvénydefinícióban megadott utasításokat végrehajtja a program. Ekkor meg kell adni a bemenő paramétereket, ha vannak.

Egy eljárás vagy void visszatérési típusú függvény hívása külön utasítást kell, hogy képezzen, egy visszatérési értékkel rendelkező függvényt pedig jellemzően olyan helyen lehet vagy érdemes meghívni, ahol a visszaadott értéket felhasználjuk (pl. kiíratjuk vagy egy változónak értékül adjuk).

Visszatérési érték

Ha a függvény nem eljárás, vagy nem void visszatérési típusú függvény, akkor a függvényhívás helyére visszaad egy értéket, amit a függvény utasításaiban a return kulcsszó után írunk.

Visszatérési típus

A függvény visszatérési értékének típusa, amit a függvénydefinícióban adunk meg. Erősen típusos és statikusan típusos programozási nyelvekben meg kell adni (pl. C, C++, C#, Java nyelvekben). Gyengén típusos, dinamikusan típusos programozási nyelvekben nem adjuk meg egy függvény visszatérési típusát, hanem valamilyen kulcsszót adunk meg helyette. Pl. Javascript nyelvben a function kulcsszót.

Paraméterek, formális paraméterek, paraméterlista

A függvény definíciójában megadott paraméterek.

Erősen típusos, statikusan típusos nyelvekben meg kell adni a paraméterek típusát és nevét.

Gyengén típusos, dinamikusan típusos nyelvekben csak a paraméterek nevét kell megadni.

A paraméterek neve csak azt jelzi, amilyen névvel a függvényen belül, a függvény blokkjában hivatkozunk a paraméterekre, de ezeknek a neveknek nem kell megegyezniük a függvényhíváskor  megadott paraméterek neveivel.

Argumentumok, aktuális paraméterek

A függvényhíváskor a függvénynek átadott literálok, változók, tömbök, objektumok, esetleg függvények.

függvény blokkja (function body)

A függvénydefiníciónak az a része, ahova azokat az utasításokat írjuk, amiket a függvény a meghívásakor végrehajt. Pl. C, C++, Java, C# nyelvekben a kapcsos zárójelek közötti rész.

függvény fejléce, prototípusa, szignatúrája, deklarációja

A függvény blokkja előtti rész (visszatérési típus és paraméterlista). Ha ezt külön megadjuk egy utasításként a függvénydefiníciók előtt, akkor a függvénydefiníciók sorrendjére nem kell ügyelni (pl. ha az egyik függvény meghívja a másikat, mert ez egy hatalmas kódban szinte átláthatatlan).

main függvény

Vannak olyan programozási nyelvek (pl. C, C++, C#, Java), amikben a program érdemi futása a main függvény első sorával kezdődik. Ezekben a programozási nyelvekben egy átlagos program kódjában mindenképp kell definiálni egy main függvényt.

Ellenpélda például a Javascript vagy PHP, ott a kód első sorával kezdődik a program futása.

függvény túlterhelése (function overload)

Ugyanazzal a névvel, de különböző paraméterlistával függvényeket definiálni.

Visszatérési típus alapján nem lehet függvényt túlterhelni, mivel a fordító nem tudná kikövetkeztetni, hogy mikor melyiket kell meghívni.

függvény mellékhatása

Egy visszatérési értékkel rendelkező függvény azon utasításai, amik nem a visszatérési érték előállításához kellenek. Pl. kiíratás, vagy egy bemenő paraméter értékének megváltoztatása.

Lokális változók

Olyan változók, amik a függvény minden egyes futtatásakor létre lesznek hozva, és a függvény futásának befejezésekor megsemmisülnek. Ezek a változók csak a függvényen belüli utasítások számára láthatóak. A függvényen kívüli utasításokban vagy más függvényekben lévő utasításokban nem használhatjuk őket.

Régies C, C++ tananyagokban auto vagy automatikus változóknak is szokták őket nevezni.

Globális változók

Olyan változók, amik nem függvények törzsében lettek definiálva, és amikhez minden függvény hozzáfér anélkül, hogy paraméterül átadnánk nekik.

Használatuk sokak szerint ellenjavallt, mivel nehéz nyomon követni, hogy melyik függvény mikor változtatja meg az értéküket.

A globális változók csak a program futásának a végén semmisülnek meg.

Statikus változók (a függvényekben)

Tulajdonképpen a lokális változók és a globális változók hibridje. Egy függvény törzsében hozzuk létre őket, viszont nem jönnek létre a függvényhívások minden alkalmával, hanem csak az első függvényhíváskor jönnek létre, és a program futásának a végén semmisülnek meg.

Egy bugyuta példa, de például ha meg akarjuk számolni, hogy egy függvény hányszor lett meghívva, akkor azt statikus változóval tehetjük meg.

Változó élettartama (variable lifetime)

Ameddig egy változó létezik. Például a lokális változók megsemmisülnek egy függvényhívás végén, viszont a statikus változók nem.

Változó láthatósága (variable scope)

Ahol egy változóra hivatkozhatunk (amíg a változó élettartama tart). Például a lokális változókra nem hivatkozhatunk a függvények törzsén kívül.
Illetve például elágazásokban, ciklusokban létrehozott változókra bizonyos programozási nyelvekben csak az elágazás vagy ciklus blokkjában hivatkozhatunk, de vannak olyan programozási nyelvek, amikben az elágazásokban, ciklusokban létrehozott változókra az elágazásokon, ciklusokon kívül is hivatkozhatunk.

Cím (referencia) szerinti paraméterátadás

Amikor egy paramétert úgy adunk át egy függvénynek, hogy annak az értékét megváltoztathatja

Érték szerinti paraméterátadás

Amikor egy paramétert úgy adunk át egy függvénynek, hogy az értéke lemásolódik, és a lemásolt értéken való módosítások nem lesznek hatással arra, amit a függvénynek átadtunk.

Konstans referencia szerinti paraméterátadás

Amikor egy paramétert úgy adunk át egy függvénynek, hogy az értéke nem másolódik le, viszont a függvény nem tudja megváltoztatni az átadott paraméter értékét.

Függvénykönyvtár (library)

Egy programozási nyelvhez mellékelt, vagy mellékelhető függvénygyűjtemény, amiben alapvető vagy hasznos függvényeket használhatunk a programjainkhoz.

Osztályok, objektumok

Az objektumorientált programozás alapvető elemei az osztályok és objektumok.

Főként két esetben használjuk őket:

1. Ha több összetartozó (akár különböző típusú) adatot együtt akarunk tárolni, illetve a rajtuk végezhető műveleteket (úgynevezett metódusokat vagy tagfüggvényeket) is össze akarjuk kapcsolni ezekkel az adatokkal.
   Például tárolhatunk személyekről, járművekről, eszközökről (pl. telefonokról, TV-kről) adatokat. Mi döntjük el azt, hogy pontosan milyen adatokat tárolunk ezekről a dolgokról.
   Például személyek esetén tárolhatunk nevet, lakcímet, telefonszámot, esetleg születési dátumot.
   Például lehet az egy művelet, hogy a születési dátum alapján kiszámítjuk az életkort. De például az is egy művelet, ha megváltoztatjuk valakinek a telefonszámát vagy a lakcímét.
2. Ha a programozásban jellemzően használt, valamilyen adatszerkezetet szeretnénk megvalósítani, amik jellemzően az algoritmusok és adatszerkezetek tantárgy témái.
   Például (ezek a könnyebbek): láncolt lista (linked list), verem (stack), sor (que), kettős végű sor (deque).
   Vagy például (ezek a nehezebbek): hast tábla, fák, gráfok.
   A legtöbb nyelvben a string típus is valójában egy osztály, hiszen vannak segédfüggvényei, amikkel például lekérdezhezjük a string karaktereinek számát vagy például a string valahanyadik karakterétől egy másik karakteréig tartó részét. A string mellett a másik gyakran használt példa a dátum típus, sok nyelvben az is egy osztály valójában.
   Ezekkel kapcsolatban azt szokták ajánlani a programnyelv készítői, hogy ha ezek közül valamelyik alapból benne van a programozási nyelvben (vagy a nyelvhez mellékelt függvénykönyvtárban), akkor használjuk azt, és legfeljebb gyakorlásképpen készítsünk sajátot.
   Vannak viszont olyanok, amik jellemzően nincsenek benne egy programozási nyelvben. Például rendezett tömb, prioritásos verem, prioritásos sor.

Mi a különbség az osztály és az objektum között?

Az osztályra tekinthetünk úgy, mint egy típusra, egy objektumra pedig egy adott osztályból (típusból) létrehozott változóra, amit konkrét adatokkal töltünk fel.

Esetleg az osztályt lehetne hasonlítani egy adatbázisban szereplő tábla fejlécében szereplő mezőinek összességéhez, ennél a hasonlatnál az objektum pedig az adott táblában egy konkrét rekordnak felelne meg.

A különbség az adatbázissal szemben az, hogy az adatbázis esetén fájlokban tároljuk az adatokat, jellemzően későbbi feldolgozáshoz, az osztályok, objektumok esetén pedig olyan adatokról van szó, amiket a programunk épp feldolgoz, amikkel a program épp dolgozik.

Példányosítás (instantiation)

Példányosításnak nevezzük, amikor egy osztályból létrehozunk egy objektumot.

Adattag, mező

Egy osztály/objektum adattárolásra alkalmas része. Ez lehet alaptípusú változó, tömb, vagy akár egy másik osztály (pl. egy todo lista esetén a todo lista egy eleme, vagy akár string vagy dátum).

Egy osztálynak/objektumnak több adattagja is lehet, és ezeknek a típusa eltérhet egymástól.

Tagfüggvény, metódus

Egy osztályhoz/objektumhoz tartozó függvény, ami az osztály/objektum adattagjaival végez műveleteket. Pl. egy todo lista esetén kiszámolja, hogy az eddig elvégzett tennivalókra összesen mennyi időt töltöttünk.

Getter, setter függvények

Egy osztály/objektum olyan tagfüggvényei, amik mindösszesen arra használhatóak, hogy visszaadják egy objektum egy adattagjának aktuális értékét (getter) vagy megváltoztassák egy adattag értékét (setter).

Ebben az esetben az adattagokat priváttá tesszük, vagyis csak ezeken a tagfüggvényeken keresztül tesszük elérhetővé őket a külvilág felé. Ez például azért fontos, mert a függvényhívások esetén könnyebb nyomon követni, hogy milyen utasítás hívta meg ezt a függvényt, pl. milyen utasítás változtatta meg egy adattag értékét.

Enkapszuláció, egységbe zárás

Egy osztálynak/objektumnak lehetnek olyan adattagjai, amiket nem akarunk getter vagy setter függvényekkel a külvilág számára elérhetővé tenni, illetve lehetnek privát tagfüggvényei is, amiket szintén nem teszünk elérhetővé a külvilág felé, csak az osztály tagfüggvényei hívhatják meg őket.

Például egy string típus esetén ilyen függvény az, ami azért felelős, ha egy stringbe hosszabb szöveget akarunk tárolni az eddiginél, akkor foglaljon le nagyobb memóriaterületet a számítógép memóriájában.

Konstruktor

Az a tagfüggvény, ami akkor hívódik meg, amikor az osztályból egy objektum létrejön.

A konstruktorban a legjellemzőbb művelet az, hogy a paraméterben megadott adatokat értékül adjuk a létrehozott objektum adattagjainak.

Viszont a konstruktort valójában 2 fontos dologra használjuk:

1. erőforrások lefoglalása, például memória allokálás, fájl megnyitása, esetleg hálózati kapcsolat megnyitása
2. a paraméterekben megadott értékek ellenőrzése (pl. egy dátum típus esetén a hónap 1 és 12 közötti szám kell, hogy legyen)

Default konstruktor

0 paraméteres konstruktor, amiben azt adjuk meg, hogyha egy objektum létrehozásakor nem lett megadva paraméter, akkor milyen default értékeket kapjanak az adattagok.

Copy konstruktor

A copy konstruktor akkor fut le, ha egy objektum létrehozásakor az objektumnak egy másik objektumot adunk értékül.

Fontos, hogy írjunk copy konstruktort az ilyen esetekhez, mivel például ha az objektumnak van egy tömbszerű adatszerkezet adattagja, akkor az nem érték szerint másolódik le, hanem cím szerint, ami azt fogja eredményezni, hogyha az új objektumban módosítunk ezen az adattagon, akkor az a régi objektumban is módosul.

Deep copynak nevezzük azt, amikor egy ilyen adatszerkezetet a copy konstruktorban lemásolunk. Jellemzően new[] operátorral új memóriát foglalunk le az új objektum adattagjának, és for ciklussal lemásoljuk a régi objektumból az új objektumba az egyes elemeit.

=operátor (értékadó operátor)

Például C++ nyelvben akkor fut le, ha már egy létrehozott objektumnak egy másik objektumot adunk értékül. Hasonló, mint a copy konstruktor, de itt azt is ellenőríznünk kell, hogy nem saját magát adjuk-e értékül az objektumnak (ez egy bonyolult kódban függvényhívások sorozatában simán előfordulhat), mert az a program hibás működéséhez vezet.

this kulcsszó

Például Javascriptben ha egy adattagra hivatkozunk, vagy egy tagfüggvényre hivatkozunk, mindig ki kell írnunk elé a this kulcsszót.

C++-ban például csak akkor, ha mondjuk egy konstruktorban a paramétereket ugyanúgy nevezzük el, mint az adattagokat, mert akkor a paraméterek elfednék az adattagokat.

Destruktor

Például C++ nyelvben azokat az erőforrásokat, amiket a konstruktorban lefoglaltunk, a destruktorban fel kell szabadítanunk. Tipikusan például a new operátorral lefoglalt memóriát delete operátorral felszabadítani. Fontos, hogy amit new[] operátorral foglaltunk le, azt ne delete operátorral szabadítsuk fel, hanem delete[] operátorral.

Garbage collector

Például Java nyelven nem kell destruktort írni, hanem egy úgynevezett garbage collector felszabadítja például a new operátorral lefoglalt memóriát, ha már nincs rá szükség.

no naked new

C++ nyelvben van egy olyan szabály, hogy ne használjunk new operátort, csak a konstruktorokban, mivel ha például függvények blokkjában használnánk new operátort, akkor ha a függvények egymásnak adogatják át a new operátorral létrehozott objektumot, akkor nehéz nyomon követni, hogy azt hol kell delete operátorral felszabadítani.

Öröklődés

Amikor egy osztály felhasználásával létrehozunk egy új osztályt, amit általában újabb adattagokkal egészítünk ki, illetve előfordulhat, hogy bizonyos tagfüggvényeit felüldefiniáljuk.

Virtuális függvény

Például C++-ban virtuális függvényként kell definiálnunk egy tagfüggvényt, ha azt a származtatott osztályokban felül szeretnénk definiálni.

Például Java nyelvben minden tagfüggvény virtuális függvény.

Felüldefiniálás

Amikor egy származtatott osztályban egy ősosztály függvényének a törzse helyett egy új törzset adunk meg, különböző utasításokkal.

Absztrakt függvény, C++-ban pure virtual függvény

Olyan tagfüggvény, aminek aminek az ősosztályban nincs megadva törzse, az ősosztályban viszont felül tudjuk definiálni.

Absztrakt osztály

Pl. C++ nyelvben olyan osztály, ami tartalmaz legalább egy pure virtual függvényt.

Pl. PHP nyelvben az abstract kulcsszóval definiált osztály. Nem kell, hogy legyenek benne absztrakt függvények.

 

//

2d tömb, tömbök tömbje, mátrix

Tárolási osztály:

Typedef (alias):

Függvénysablon (function template):

Pointer:

Struktúra (struct adatszerkezet):

Többszörös öröklődés:

Osztálysablon (class template):

Névtér: