Java és C Függvények

Függvények Használata

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

Többször beszéltem már a függvények használatának fontosságáról (többek között Programok működésének felépítése és Függvény és Változó nevek). De még nem beszéltem arról, hogy pontosan, hogyan is kell létrehozni illetve használni a függvényeket. Ez az egyik alapvető része a programozásnak, ezért következzen most egy rövid gyakorlati bemutatás.

 

 

Ez a bemutató érvényes mind a Java, mind pedig a C nyelvre, minthogy a függvények használata mind a két nyelvben ugyanúgy történik, de én most mégis egy rövid Java programban fogom végigvenni a lényeget.

 

Mielőtt rátérnék a gyakorlati részre, gyorsan nézzük meg, hogy elméletben mit is jelent egy függvény a programozásban?
Egy függvény nem más mint egy végrehajtható kódhalmaz, ami mindig ugyanazt csinálja, éppen attól függően, hogy milyen céllal hozták létre az adott függvényt. Tekintsünk a függvényre úgy mint egy fekete doboz, nem kell feltétlen ismernünk a tartalmát, van valamilyen bemenete és abból valamilyen módon előállítja a kimenetét. Ezt a dobozt (a függvényt) bárhonnan fel lehet használni, meg lehet hívni. Egy ilyen függvényhívás során, a függvényben lévő kódhalmaz végrehajtódik. A függvények célja nem más, mint a program egyes részeinek feldarabolása. Mintha egy könyv tartalmát fejezetekbe osztanánk fel, úgy osztjuk fel a programot különböző függvényekbe. Illetve mivel egy függvényt többször is meghívhatunk, ezért a program egy fontos részegységét elég egyszer lekódolni és azt utána tetszőlegesen sokszor felhasználhatjuk. Minden függvényhívás során ugyanaz a kód fog végrehajtódni, függetlenül attól, hogy a függvényt honnan hívták. Attól, hogy a függvény végrehajtása befejeződött, attól még maga program nem ér véget, hanem onnan folytatódik tovább ahonnan a függvény meg lett hívva. Két fontos lépés van:

  1. A függvényhívás helye
  2. A függvény tartalma

Read More

Függvény és Változó nevek

Ebben a témában: Alapok

Sokan lényegtelennek tartják az egyes függvények vagy változók precíz elnevezését a mindennapi munka során, azonban szerintem ez egy nagyon fontos pont. Funkcionalitás tekintetében lehet, hogy nem tűnik olyan lényegesnek mindez, azonban a kód karbantarthatóságát tekintve ez az egyik legfontosabb szempont.

 

Azért egy nehéz kérdés ez, mert a fejlesztőnek, aki épp implementálja az adott függvényt, annak triviális, hogy egy változó épp mikor mit jelent. Ezért szinte fel sem tűnik neki, hogy 2 hét vagy 2 év múlva mennyire értelmezhetetlen is lesz majd a kód. Sajnos sokszor láttam már ilyet illetve nekem is kellett már ilyen minőségű kódot megértenem. Nem egy nagy öröm ez, remélem nektek nem kell ezt átélni, azonban sajnos az eddigi tapasztalatom nem ezt mutatja. Nézzük meg az elméletet, hogy mikor ideális szerintem egy függvény vagy egy publikus, globális változó elnevezése:

  1. A programozás nyelve az angol. Angol a függvénynév, a változó, a komment, minden.
  2. A név hierarchia szerint épül fel (azért ezt nem érdemes túlzásban vinni, 1-2, nagyon maximum 3 szint bőven elegendő)
  3. A hierarchiai szintek általában rövidítve szerepelnek
  4. Az utolsó rész legyen a függvény vagy változó célja. Ez általában egy szabadabb rész, tetszőleges, rövid! tartalommal
  5. A függvény vagy változó végén postfix-ként szerepel a típus megnevezés
  6. Egybeírás esetén minden új szó nagybetűvel kezdődik
  7. Elválasztás esetén az elválasztó karakter az alul vonás „_”

 

A fenti szabályrendszert én mindig függvényekre és publikus, globális változókra alkalmazom. A függvény lokális változóknak és a függvény paramétereknek az elnevezésében általában nem használok hierarchia szinteket, ennyiben egyszerűsödik a dolog.

 

Nézzünk egy jó példát egy C függvényre, ami 3 számot tud összeadni:

int Pti_SumOfThreeNumbers_s16(int NumberOne_s16, int NumberTwo_s16, int NumberThree_s16);

 

Egy függvény ami megjeleníti az eredményt:

void Pti_PrintResult(int Result_s16)

 

Érdemes nagyon odafigyelni az elnevezésekre, mert ha valaki belenéz az implementációnkba, akkor ez az első dolog amit meglát. Fontos, hogy könnyen és gyorsan meg lehessen érteni a forráskódunkat, ellenkező esetben mindenkitől sokkal több időt rabol el ez a feladat mint amennyit feltétlenül szükséges lenne és akaratlanul is ellenszenvet válthatunk ki másokban. A mai komplexitású SW-ekben pedig a mindennapi munka része, hogy a kollégáink által írt kódot kell tudnunk megérteni. A problémákat, összetűzéseket azonban egy kicsi odafigyeléssel el lehet kerülni.

Read More

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

Ennél a formánál garantált, hogy a ciklus egyszer lefut! A nevét onnan kapta, hogy a feltétel ellenőrzés a ciklus végén történik. Íme a váza ennek a formának:

Read 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?

Read More

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

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

Az előző cikkben már megnéztük az egyik legalapvetőbb programozási eszközt, a feltétel vizsgálatot. Most ehhez hasonlóan szeretnék bemutatni egy szintén nagyon alapvető elemet, az ismétléses utasítás végrehajtást. Gyakran találkozunk olyan feladattal, amikor van egy nagyobb bemeneti adathalmaz és annak minden elemén ugyanazt az utasítást kell végrehajtani.

Ha a mostani ismereteinkkel közelítenénk meg ezt a problémát és feltesszük, hogy ismerjük, hogy pontosan mennyi bemeneti adatunk van, akkor minden feldolgozási lépést leprogramoznánk minden bemenetre. Ez a módszer maximum 5-10 adat esetén még esetleg működőképes lehet, de el lehet képzelni, hogy több száz vagy akár még több adat esetén már kivitelezhetetlen. Pontosan ilyen problémákra találták ki az utasításismétlést, ami az alábbiak szerint épül fel:

  1. Meddig kell ismételni az utasításmagot
  2. Maga az utasításmag

Addig hajtja végre a program újra és újra ugyan azt a blokkot, ameddig a megadott feltétel teljesül. Tehát mondjuk, ha ötvenszer kell végrehajtani egy kiírató utasítást, akkor az valahogy így nézne ki:

i := 0

[i < 50]

{

Kiíratás

}

 
Ennek megvalósítására több szintaktikai eszköz létezik C-ben és Java-ban is, de ezek egyenértékűek, átjárhatóak. Én azt gondolom, hogy a legismertebb az úgynevezett FOR Ciklus, ami az alábbiak szerint épül fel:

for(inicializálás; feltételvizsgálat; paraméter kezelés)

{

utasításmag

}

 

Read More

Feltételvizsgálat a Programozásban

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

A való életben rengetegszer kell meghoznunk különböző döntéseket. Ilyenkor általában először mérlegeljük a lehetőségeket majd azoknak megfelelően cselekszünk. Ez a gondolkodás olyan nagy hatással van az egész életünkre, hogy a programozási nyelvekben is megjelenik.

A programozásban nagyon sokszor fordul elő olyan feladat, amikor bizonyos feltételek teljesülését kell vizsgálni, a feltételek teljesülésétől vagy nem teljesülésétől függően pedig végre kell hajtani különböző utasításokat. Ezek a vizsgálatok a HA – AKKOR – EGYÉBKÉNT szerkezetben valósulnak meg. Ilyen feltétel vizsgálatokat leggyakrabban a program bemeneti paraméterein végzünk, de alkalmazhatjuk kivételkezelésre vagy éppen azt is megvizsgálhatjuk, hogy egy műveletet sikeresen végre tudtunk-e hajtani. Mivel nagyon gyakran van rá szükség ezért a legtöbb programozási nyelvben egy alapvető nyelvi elem a feltétel vizsgálat. Így olyan nyelvtani mondatok fordíthatóak át egy programozási nyelvre, mint például a HA szerda van, AKKOR nyolckor, EGYÉBKÉNT kilenckor kelek.

 

Vegyünk egy nagyon egyszerű példát és nézzük meg pszeudokódban, hogy ez hogyan néz ki:
Először gondolok én egy számra majd gondolj te is egy számra, HA a két szám összege páros AKKOR én nyertem EGYÉBKÉNT te nyertél:

HA

    • Az Én számom és Te számod összege Páros

AKKOR

    • „Én nyertem”

EGYÉBKÉNT

    • „Te nyertél”

 

Tehát egy feltétel vizsgálatnak mindig legalább 2 része van, legfeljebb pedig 3:

  1. A feltétel
  2. Mit kell csinálni, ha a feltétel teljesül
  3. Mit kell csinálni, ha a feltétel nem teljesül (opcionális, ha nincs definiálva, akkor nem csinálunk semmit)

A feltétel lehet komplex vagy egyszerű. Egyszerű feltétel esetén, csak egyetlen vizsgálatunk van, komplex esetben viszont akár több feltétel egyidejű teljesülését is tudjuk vizsgálni valamilyen kapcsolatban. Ez a kapcsolat általában VAGY vagy ÉS kapcsolat szokott lenni.

  • VAGY kapcsolatban elegendő, ha a feltétel valamely része teljesül: HA süt a nap VAGY hétvége van, AKKOR boldog vagyok.
  • ÉS kapcsolatban pedig minden feltételnek egyszerre kell teljesülnie: HA van itthon sonka ÉS tojás AKKOR rántottát csinálok

 

Nézzük meg a pszeudokódunkat C és Java programozási nyelven:

Read More

Ki a Junior Programozó?

Ebben a témában: Alapok, Onfejlesztes

Eddig már több szemszögből megnéztük, hogy mit csinál egy programozó?, hogyan lehet megtanulni programozni egyetem nélkül. Most azt szeretném körbejárni, hogy ki is a Junior Programozó, mikor lesz valaki Junior Programozó és milyen egy átlagos felvételi interjú egy Junior programozói pozícióra.

 

Ebben a szakmában annak a minimális szintnek a neve, amivel már valóban el lehet érni egy sikeres felvételit, az az úgynevezett Junior pozíció. Ha ezt a szintet valaki sikeresen elérte és sikeresen megpályázott egy állást, akkor szerintem a legnehezebb részeken már túl van. Ugyanis míg tipikusan a Junior programozói szintet otthoni tanulással és gyakorlással lehet elsajátítani, addig a Senior és a magasabb szinteket már sokkal inkább a valódi munkahelyi, ipari tapasztalatokkal lehet elérni.

 

Junior szinten még nem várnak el nagyon mély technikai tudást és több éves tapasztalatot. Sokan azt mondják, hogy a Junior programozói szintet akkor éri el valaki, ha kialakult a megfelelő algoritmikus gondolkodásmódja, feladatmegoldó képessége és nem csak magát a megoldást látja, hanem a kezében van az eszköz is a megoldáshoz. Egy Junior Programozóval szemben nem elvárás, hogy egy adott programozási nyelvet és az arra épülő összes technikát mélyen ismerjen. Inkább legyen egy erős alapja a programozási nyelvről, legyen tisztában azzal, hogy léteznek olyan kiegészítő programok, eljárások, amik gyorsítják a munkát. Ha ezek megvannak, akkor már lehet mire építeni és egy sikeres felvételi után a következő 1-2 évben el lehet mélyíteni ezeket az ismereteket valódi munkahelyi feladatokon keresztül.

 

A programozási ismereteken túl egy Junior programozóval szemben elsődleges elvárás legalább egy idegen nyelv ismerete (angol/német), a tanulási hajlandóság, a konstruktív hozzáállás, a csapatmunka és szerintem az egyik legfontosabb, az alázat. Tudd magadat reálisan megítélni, tudd, hogy még nem te vagy legjobb, még sokat kell tanulnod és sokat is akarj tanulni. Ha azt látja a leendő munkaadód, hogy igen még nem teljesen letisztult minden, vannak még esetleg hiányosságok, de akarsz fejlődni, akkor az nagyon sokat jelent. Én például amikor először gyakornoknak jelentkeztem, akkor azt mondtam az interjún, hogy ingyen is elvállalnám a munkát, mert nem a pénz motivál, hanem az, hogy tanulhassak. Mint később kiderült, ez egy nagyon szimpatikus kijelentés volt, amit a mai napig vallok, mert egy ilyen pozíciónak nem az a célja, hogy meggazdagodj, hanem egy kaput, egy hatalmas ugródeszkát jelenthet, ha jól használjuk.

 

Mindezen felül „el is kell tudnod adni magadat”, ugyanis ha egy állásinterjún az előbb felsoroltakat nem tudod bemutatni, akkor a leendő munkaadód nem fog tudni mi alapján felvenni téged, hiába szeretne. Ez utóbbi gyakorlással elsajátítható, 4-5 állásinterjú után ezzel szerintem már nem lehet gond.

Read More