Vezérlési szerkezetek, Control Flow

Vezérlési szerkezetek

Láttuk, hogy egy programkód hogyan fut le fentről lefelé. Amilyen parancsot csak leírunk, azt a számítógép egymás után, sorról sorra szorgalmasan végrehajtja. Ezt nevezzük az utasítások szekvenciájának.

A vezérlési szerkezetek összetevői lehetnek utasítások és egyéb vezérlési szerkezetek is. Ez azt jelenti, hogy ciklusokba beágyazhatunk egyéb ciklusokat, elágazásokba elágazásokat és keverhetjük is őket bármilyen mélységben.

Ha mindhárom vezérlési szerkezet elérhető egy programozási nyelvben (vagy bármi egyéb rendszeren belül), akkor bizonyítottan bármilyen számítást univerzálisan meg tudunk oldani az adott eszközzel.

Szakkifejezéssel élve ezeket a rendszereket Turing-teljesnek nevezzük.

A legtöbb programozási nyelv Turing-teljes, ám nem mindegyik. Bizonyos nyelveket nem arra alkottak meg, hogy egy számítást írjanak le, hanem inkább adatszerkezeteket: Pl.: HTML, XML, JSON.

Ezzel szemben bizonyos egyéb …hát dolgok, amik nem programozási nyelvek furcsa módon Turing-teljesek.

‣

Példák:

Kódblokk, változók hatásköre, indentálás

Block / Code Block / Blokk / Kódblokk

Egy nyitó és egy záró kapcsos zárójel közti részt C#-ben kódblokknak vagy egyszerűen blokknak nevezzük.

Ilyen blokk egy elágazás egyik ága is még abban az esetben is, ha egysoros a blokk és ezért elhagyjuk a kapcsos zárójeleket.

Ha egy változót egy blokkon belül hozunk létre, az csak abban a blokkban fog létezni. Azon kívül nem értelmezett, nem hivatkozható. A tartományt, amiben az adott változó elérhető, a változó hatáskörének nevezzük.

if (num < 0)                       // Ha "num" kisebb nullánál,
{
    int absoluteValue = -num;      // kiszámoljuk az abszolútértékét.
}

Console.WriteLine(absoluteValue);  // !!! HIBA !!!
// Unityben Debug.Log() paranccsal tudnánk kiírni a konzolra.

A C# kód ideális formázása szerint minden nyitó kapcsos zárójellel eggyel több tabulátort hagyunk a sor elején és minden zárással eggyel kevesebbet. Ezt nevezzük indentálásnak, ami nagyban segít olvashatóan tartani a kódunkat.

// Ez a kód csak a helyes indentálást szemlélteti, ne próbáljátok leforítani.

class SomeClass         // Ez egy osztály (Később tanuljuk)
{
		void SomeMethod()   // Ez egy metódu (Később tanuljuk)
		{
				if(someCondition)
				{
						while(someOtherCondition)
						{
								Console.WriteLine("ABC");
						}
				}
				else
				{
						Console.WriteLine("DEF");
				}
		}

		void SomeOtherMethod()
		{
				Console.WriteLine("GHI");
		}
}

Az ideális C# forlmázásról bővebben: C# Puska 5 - Kódolási konvenciók

Kiegészítő anyag: Strukturált programozás és a Control flow

Az elágazások és ciklusok nem ismert fogalmak a számítógép hardvere számára. A processzor semmi mást nem tud csak parancsról-parancsara végrehajtani egy memóriában lévő utasítás sort.

Van viszont egy olyan művelet minden számítógépben, hogy “Ugrorj valahova máshova a memóriában, ha igaz valamilyen feltétel”. Ezt nevezzük jump utasnak.

A korai programozási nyelvekben nem léteztek elágazások és ciklusok, helyette a jump paranccsal egyenértékű goto utasítás volt használatos.

Ha végig követjük egy program futását, akkor annak van egy úgy nevezett control flow-ja, vagy vezérelt folyamata. Mindig tart a számítógép a végrehajtásban egy konkrét parancsnál, ami aztán ugrik a következőre és így halad a control flow. Gondolhatunk úgy is a control flowra mint egy nagy hosszú fonálra, ami végig szövi a kódunkat. Egy if-nél a fonál két irányba mehet, a while- nál egy hurkot tesz.

Ha kizárólag goto utasításokra hagyatkozunk azzal könnyedén eredményezünk követhetetlen folyású kódot. Az ilyen kódot spagettinek szoktuk csúfolni, ugyanis a control-flow-ja olyan könnyen bogozható ki, mint egy tál spagettitészta.

Ha belegondolunk, akkor egy elágazás, csak egy feltételes előre ugrás egy ciklus pedig csak egy feltételes hátra ugrás a kódban, tehát csak egy szintakitikailag különböző a goto utasítás.

Sőt mi több, minden elképzelhető kód bizonyítottan megoldható elágazásokkal és ciklusokkal is, ám az átalakítás nem mindig triviális.

Ezek a programozói eszközök, mint az if, while már jó ideje jelen voltak a programozásban, ám a 60-as évektől kezdően egyre több programozót foglalkoztatott a kérdés, hogy érdemes-e teljesen száműznünk a goto-t a programozási eszköztárunkból.

Ezt a hozzáállást a programozáshoz strukturált programozásnak nevezik és támogatói mellett sok kritikusa is akadt.

Totális győztese nem lett a goto vs. strukturált programozás vitának. A ma használt népszerű programozási nyelvek és fejlesztési stílusok egy köztes modellt támogatnak.

Maga a goto utasítást a legtöbb nyelvben, így a C#-ban sem javasolt (szinte) sehol sem használni, viszont bizonyos esetekben más eszközök felváltották a helyét, amikkel elérhető nem tisztán strukturált programozás:

• break és continue utasítások a ciklusokban és a többágú switch elágazásoknál.
• A metódusok korai visszatérése is. (Több return egy metódusban)
• Kivételkezelés, aza try-catch modell.