Month: September 2017

Ismétléses utasítások – A While Ciklus

Ebben a témában: Alapok, C Programozas, Java Programozas

Egy korábbi cikkemben már bemutattam a ciklikus végrehajtás fontosságát. Java és C programozásban egy ciklus létrehozására két fajta nyelvi elem létezik, a korábban már bemutatott For ciklus és az úgynevezett While ciklus.

 

A két nyelvi elem mindig átjárható, tehát egy adott szituációra bármelyik használható. Azt, hogy ki melyiket választja az inkább helyzet és megszokás kérdése. A leglényegesebb különbség a kettő között, hogy amíg a For ciklusnál a létrehozáskor egy sorban meg tudjuk adni a feltételt és a ciklus számlálót, addig a While ciklusnál csak a feltételt tudjuk közvetlenül definiálni. A ciklusváltozó kezelését magunknak kell megoldani! Ez tipikusan azt jelenti, hogy a ciklus előtt már létre kell hoznunk a ciklusváltozót és a cikluson belülről kell növelnünk az értékét, ciklusonként egyszer.

 

Röviden vegyük át ismét a ciklusok működésének alapelvét:

  1. Meddig kell ismételni az utasításmagot, feltétel megadása
  2. Maga az utasításmag

A While ciklusnak két fajtája van:

 

  1. Elöl Tesztelő Ciklus

Azért elöl tesztelő, mert már az első végrehajtás előtt ellenőrzi a megadott feltételt, tehát nem biztos, hogy a ciklus egyszer is végre fog hajtódni. Az elöl tesztelő ciklus szintaktikailag így épül fel:

while(condition)

{

…

}

 

Látható, hogy a létrehozása jóval kevesebb karakterből megoldható mint egy For ciklus esetében (ez azonban nem biztos, hogy előny), mindössze a While kulcsszót és egy feltételt kell leírnunk. A ciklus addig fut amíg a feltétel teljesül. Nézzünk egy konkrét példát, adjuk össze az egész számokat 1-től 5-ig:

int baseNumber = 5;

int result = 0;

while (baseNumber > 0)

{

result = result + baseNumber;

baseNumber--;

}

 

Amire ennél a formánál nagyon oda kell figyelni, az a ciklusváltozó kezelése a cikluson belül. Nem hívja fel rá semmi a figyelmünket, ezért könnyen el tud felejtődni!

Nézzük meg ugyanezt a feladatot For ciklussal:

int result = 0;

for(int baseNumber = 5; baseNumber > 0; baseNumber--)

{

result = result + baseNumber;

}

 

 

  1. Hátul Tesztelő Ciklus

(more…)

Programok működésének felépítése

Ebben a témában: Alapok, C Programozas, Java Programozas

Amikor valaki elkezd programozással foglalkozni, programozást tanulni, akkor mindig az első leckék között szerepel, hogy megértsük, hogy hogyan is működnek a programok. Milyen sorrendben hajtódnak végre egymás után az utasítások, hogyan épül fel egy program.

 

Egy program nem más, mint utasítások szekvenciális végrehajtásának halmaza.

Kezdjük a legegyszerűbb eshetőséggel, az egyszálú programokkal. Mit jelent ez?
Azt, hogy van egy fő szál, ami szekvenciálisan hajtja végre az egymás után következő utasításokat. Nézzünk erre egy példát:

int a = 2;

int b = 3;

int c, d;

c = a+b;

d = c*a;


Hogyan fognak egymás után lefutni az utasítások?

Felülről lefelé. Először létrejönnek egymás után a változók „a”, „b”, „c” és „d”. A változók vagy úgy jönnek létre, hogy van valamilyen dedikált kezdőértékük („a”, „b”) vagy úgy, hogy csak létrejön, de nem kap értéket („c”, „d”). Ezután kiszámoljuk „c” értékét majd végül pedig „d” értékét. Nincsenek kereszthatások és nincsenek ugrások sem. Mi történik, ha megcserélem „c” és „d” kiszámításának sorrendjét?

Mivel „d”-nek bemenete „c”, de mivel „c” csak „d” után kap számolt értéket, ezért nem tudjuk megmondani pontosan, hogy mi lesz „d” értéke. Azonban a program továbbra is működőképes marad, de biztosan kapunk egy hatalmas figyelmeztető üzenetet, hogy úgy használunk fel egy változót, hogy annak értékét mi magunk még sosem állítottuk. De hogyan lehetséges ez?
Úgy, hogy valamilyen előre nem definiált értéket minden változó kap a létrehozásakor, ha mi magunk nem állítunk be semmilyen kezdőértéket. Ez az érték igazából bármi lehet, nem lehet előre megmondani. Ez egy nagyon gyakori hiba és veszélyes szituáció, éppen ezért komoly figyelmeztetéseket küld ilyen esetben a fordító és a fejlesztő környezet is, ha észreveszi. Éppen ezért a legjobb megközelítés, amit én mindenkinek kifejezetten ajánlani szoktam, hogy mindig minden változónak adjunk kezdőértéket! Ez sokszor feleslegesnek tűnik, de ha egyszer bekerül a napi rutinba akkor sok fejfájást meg tudunk spórolni.


Függvények

Egy jól strukturált kód első ismérve a függvények megfelelő minőségű és mennyiségű használata. Mi is pontosan egy függvény?
A programozásban használt függvények analóg módon működnek a matematikában megszokott függvényekhez. Azaz valamilyen bemeneti adatokból valamilyen módon előállít kimeneti adatot vagy adatokat, áttranszformálja a bemeneti adatokat kimeneti adatokká. Azt, hogy ezt pontosan hogyan teszi, az már a függvénynek a belső hatásköre. Ezért ami fontos, hogy minden függvénynek (mostmár a programozásbeli függvényekről beszélek) kell, hogy legyen egy jól definiált bemeneti és kimeneti leírása. Pontosan milyen bemeneti adatokból milyen kimeneti adatokat fog előállítani. Persze a belső működésének a leírása is mindig szükséges, de vannak olyan szituációk amikor az nem feltétlenül fontos számunkra, csakis a bemenetek és a kimenetek.


Hogyan néz ki egy függvény deklarációja a programozásban?

VisszatérésiÉrtékTípusa FüggvényNév(Parameter1Típusa Parameter1, Parameter2Típusa Parameter2, …, ParameterNTípusa ParameterN) { … }


Deklaráljuk az összeadás függvényt, ami 2 számot ad össze:

int SumOfTwoNumbers( int Number1, int Number2) { … }

VisszatérésiÉrtékTípusa int
FüggvényNév SumOfTwoNumbers
Parameter1Típusa int
Parameter1 Number1
Parameter2Típusa int
Parameter2 Number1



Minden függvénynek kötelező, hogy legyen be és kimenete is?

(more…)