Lottószimulátor - Futtató program

Most hogy készen van a Szelveny osztály, teszteljük azt. Ehhez kell egy úgynevezett tesztelő vagy futtató program. Nézzük meg hogy miért is van ez.

A Java tisztán objektum-orientált nyelv. Ez azt jelenti hogy minden objektum a programban. Az objektumok valamilyen osztály egy-egy példánya, mely a példányosítás során jön létre. Az egyes objektumpéldányok létrehozása kostruktorral történik. Ha nem definiálunk konstruktort akkor is létezik az osztály nevével azonos nevű metódus. Ennek fő feladata a memóriafoglalás és az objektum kezdeti állapotának beállítása. A Szelvény osztálynak két konstruktort definiáltunk. Egy paraméterezettet és egy paraméter nélkülit. A példányosítás után az objektumnak a publikus metódusain keresztül üzeneteket tudunk küldeni, illetve a publikus adattagok közvetlenül elérhetők (ezt én kerülendőnek tartom még akkor is ha triviális lenne a megoldás).

Minden osztályt külön forrásfájlban (.java kiterjesztésű fájl) kell definiálni. A forrásfájl nevének meg kell egyezni az osztály nevével. Így lett a Szelveny osztályunk a Szelveny.java fájlba definiálva.

Amikor egy osztályt a virtuális gépbe betöltünk akkor a JVM megpróbálja elindítani az osztály main() metódusát. Ha ilyet talál akkor elindul a metódus. Így indíthatók a programok.

Hozzunk létre most egy LottoTest osztályt, amibe létrehozzuk a main() metódust. Ennek is szabályai vannak, az alábbi kötött formában kell definiálni a main()-t.

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.    }
11. }

Ezzel létrehoztunk két objektumot, melyek tartalmaznak tippeket. Ezeket a tippeket írassuk most ki!
Rá kell jönnünk hogy a szelvény osztályban nem készítettünk metódust a kiíratásra, az adattag ami a tippeket tartalmazza az pedig private (nagyon helyesen), amihez ugyebár az objektumon kívülről nem lehet hozzáférni. Készítenünk kell hát valamilyen metódust ami kiíratja, vagy visszaadja a tippeket.
A Java-ban szokás definiálni egy toString() metódust. Ez kvázi szabvány. A metódus visszaad egy String típusú értéket mely tartalmazza azt a szöveget, amit az objektum adatairól  tartalmaz információt. Most ezt fogjuk megadni. Egyébként a számok tárolására használt TreeSet konténernek is van "gyári" toString() metódusa, amit fel is használunk.
Természetesen a Szelveny.java fájlt kell kiegészíteni a következő sorokkal:

1. public String toString(){
2.    // a TreeSet objektum toString() metódusát úgy írták meg hogy
3.    // [] jelek között, vesszővel elválasztva felsorolja
4.    // növekvő sorrendben az elemeit. Ez nekünk teljesen megfelel!
5.  
6.    return "Szelvény száma: "+szelvenyId+" Tippek: " + tippek.toString();
7. }

Ezek után már a tesztelő osztályunkban a példányosítások után használhatjuk is a szelvények toString()-jét a kiíratásra.

A kiíratáskor a kiertekel() metódust felhasználva, értékeltessük is ki a szelvényeket.

Ez lesz a tesztelő osztályunk tartalma:

1. public class LottoTest {
2.    public static void main(String[] args){
3.      //létrehozunk két szelvényt
4.      //sz1 automatikusan generált 5 számot fog tartalmazni
5.      Szelveny sz1 = new Szelveny();
6.      
7.      //sz2 a paramétrelistájában megadott öt számot tartalmazza
8.      Szelveny sz2 = new Szelveny(19,71,8,16,7);
9.  
10.      // ha nem adjuk meg cska az objektum nevét, akkor megpróbálja megfelelő típusúra konvertálni.
11.      //String típushoz a toString() metódust hívja automatikusan.
12.      System.out.println(sz1 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));
13.      System.out.println(sz2 + " Találatok száma: " + sz1.kiertekel(2,7,18,71,87));    
14.  
15.    }
16. }

Futtatás hatására a kimenet hasonló lesz  (valószínű más számok jelennek meg az sz1 kiírásakor)

Szelvény száma: -1 Tippek: [8, 51, 66, 71, 75] Találatok száma: 1

Szelvény száma: -1 Tippek: [7, 8, 16, 19, 71] Találatok száma: 2

Lottó szimulátor - osztályok első nekifutásra

A lottó szimulátorral kapcsolatban először gondoljuk át hogy milyen osztályok szükségesek az alkalmazáshoz.

A Java egy tisztán objektumorientált programozási nyelv és mint minden ilyen nyelvben osztályokkal és az osztályok alkotta osztályhierarchivál dolgozunk. Az osztályok a való világ egyes elemeinek, objektumainak absztrakció útján történő leképezései.
Most próbáljuk meg a feladattal kapcsolatban az első absztrakciót elvégezni. Képzeljük el hogy milyen osztályok és azok milyen kapcsolatai fogják alkotni a Lottószimulátort! Most nem törekszünk teljes részletességre, csupán nagy vonalakba gondoljunk a feladatra.

A lottófogadásokat szelvényeken tudjuk megtenni. Az összes fogadást és azok kezelését is meg kell valósítani egy közös helyen. Első menetben erre a két osztályra lesz szükségünk.

Nézzük ezeket részletesebben.

Szükség lesz (vagy nem?) egy olyan osztályra, ami a tippek tárolására alkalmas. Ezt úgy kell elképzelni mint a fogadó fejében lévő lottószámok, amiket meg szeretne tenni. Tehát semmi más nem jellemzi, csak maguk az ember elméjében létező számokat tartalmazza, amiket vagy megtesz a lottón vagy nem. Tehát ez még nem maga a fogadás ez csak egy tipp. Ahhoz hogy fogadás legyen belőle, ahhoz ki kell tölteni egy lottószelvényt. A kérdés az hogy maga a számsor, ami egyéb más jellemzővel nem rendelkezik azt szükséges-e külön osztályban megvalósítani vagy sem. Elsőnek induljunk el úgy hogy mégse csináljunk ebből külön osztályt.

Tehát a tippet már eleve egy szelvényen kezeljük, mert amíg nem teszik meg a fogadást addig tökmindegy hogy benne van-e valaki fejében öt szám vagy sem.

A lottószelvény osztálynak tárolni kell tudni az öt számot, illetve van egy 7 jegyű egyedi sorszáma amivel majd a joker játékra lehet fogadni. A sorszámot a szelvény létrehozásakor generáljuk. A lottószelvény a sorsolás után lehet nyertes szelvény akkor, ha legalább két találat van rajta. A szelvényobjektumnak a létrehozásakor vagy megadjuk az öt számot amire fogadást kötnek, vagy ha nem akkor generálunk öt számot. Ez tehát kétféle konstruktort jelent (többalakúság). Az hogy egy szelvény nyertes-e, azt egy metódussal fogjuk kiértékelni. Paraméterül adjuk át a kihúzott öt számot és eredményül adja vissza hogy hányas találat van a szelvényen.

Az implementációban az öt lottószám tárolására használjunk egy konténert. Ehhez használjuk a TreeSet tárolóosztályt, aminek az a jellemzője, hogy egy elemet csak egyszer tartalmazhat és az elemeket rendezve tárolja. Természetesen Integer elemekkel dolgozunk. A generálást a Math osztály Random() metódusával generáljuk. Ez a 0 és 1 között generál egy lebegőpontos véletlen számot. Ezt először 1 és 90 közöttivé kell alakítani, majd típuskényszerítéssel (cast) egésszé kell alakítani.

Íme a lottószelvényeket tároló osztály Java forrása:

public class Szelveny {
  private int szelvenyId = -1; //jelöljük így a szelvényt amíg nincs sorszáma
  private TreeSet tippek = new TreeSet();
  private boolean joker = false;

  public Szelveny(){
     //generálni kell 5 különböző számot 1-90 között.
     //Ha egy számot már kisorsoltunk, akkor helyette új kell
     for(int i=1;i<=5;i++){
         int j;
         do 
            j=(int)(Math.random()*89+1);             
         while(tippek.contains(j));
         tippek.add(j);
     }
  }

  public Szelveny(int n1, int n2, int n3, int n4, int n5){
     //paraméterekben megkapjuk a tippeket. 
     //Az hogy a tippek helyesek-e azzal ne foglalkozzunk. 
     //Nem tudjuk hogy mi volt a célja a szelvény kitöltőjének, 
     //had töltse ki ahogy akarja. Majd a szelvény beadásakor 
     //kell eldönteni hogy elfogadjuk-e a tippet, vagy sem.

     tippek.add(n1);
     tippek.add(n2);
     tippek.add(n3);
     tippek.add(n4);
     tippek.add(n5);

  }

  public int kiertekel(int n1, int n2, int n3, int n4, int n5){
     //le kell ellenőrizni az öt számot egyenként.
     //a -1 azt jelenti hogy érvénytelen a szelvény
     int talalat = -1; 

     // érvényes a szelvény ha 5 tippet tartalmaz
     if (tippek.size()==5) talalat++;
     if (tippek.contains(n1)) talalat++;
     if (tippek.contains(n2)) talalat++;
     if (tippek.contains(n3)) talalat++;
     if (tippek.contains(n4)) talalat++;
     if (tippek.contains(n5)) talalat++;

     return talalat;
  }
}

LOTTÓ feladat Javában

Nemrég nézegettem az emelt szintű informatika érettségi feladatokat és ott láttam egy lottózós feladatot. Erről jutott eszembe, hogy csináljak gyakorlásként egy ilyen lottózós példát.
Java-ban fogom megcsinálni, lehet hogy nem egy lépcsőben hanem szépen lépésről lépésre.
Itt fogom blogolni, hátha hasznos lesz valakinek.


Előszöris a feladatot kéne megfoglamazni első lépésben, aztán lehet hogy még pontosítjuk.

Szóval a cél egy lottó szimulátor készítése a következő funkciókkal:

• 5-ös lottó (90-5) feladatról van szó
• Lehessen megadni fogadásokat (akármennyit)
• A fogadásokról készítsen statisztikát (később pontosítjuk hogy mit statisztikázzon)
• Sorsolja ki a nyerő számokat
• Statisztikázza és listázza ki a nyertes szelvényeket.
• Lehessen a lottószelvény sorszámával joker-re is fogadni.
• Sorsolja ki a jokert

Hát egyelőre ennyi feladat lenne. Rengeteg ötlet jut hirtelen eszembe amit még meg lehetne valósítani. (pl. fordított lottó. Először sorsoljon, aztán kezdjen el generálni fogadásokat addig amíg lesz egy 5-ös szelvény, vagy 4-es stb...)

A fent felsorolt pontokból indulok ki és ahogy haladok, blogolni fogom a részfeladatokat... (remélem)

Egy kis retro érzés: Mi és a computer

A minap néztem az M3-at és éppen a számítógépről illetve annak programozásáról beszélgettek. Egy 1983-as ismeretterjesztő sorozat egyik epizódjába botlottam, a címe: Mi és a computer.
Tovább nézve az epizódot mindjárt tudtam hogy valahogy meg kell néznem minden epizódját, hiszen amiről bezséltek, amilyen gépeket és programokat használtak azok pontosan azok voltak amiket én magam is használtam akkor amikor összetalálkoztam az informatikával. A riportokban az akkori kissrácok ugyan azokról a dolgokról érzésekről bezsélnek amit én éreztem és átéltem.
Szerencsére a youtube-on elérhető a sorozat minden része.
A programozni tanulóknak is ajánlom, mert vannak benne feladványok, magyarázatok a programozással kapcsolatosan, gyakran nem is olyan egyszerűek ezek. Meg lehet próbálni megoldani ezeket a feladatokat.
Az egyik ilyen feladat pl az volt hogy egy maximum 10 soros verset elemezzünk és adjuk meg a rímképletét. Izgalmas és nem feltétlenül egyszerű feladat, Oldjuk meg! :)

Programozás oktatás (www.learneroo.com)

A napokban találtam egy weboldalt ahol különféle programozással kapcsolatos oktatóanyagok vannak. Az oldal néhány programozási nyelv mellett főként az alábbi témákat oktatja:

Programozási nyelvek közül az aktuális trendnek megfelelően a Java, JavaScript, Python és Ruby nyelveket oktatja rengeteg rövid, gyakorlati feladatok használatával.

Ami leginkább megtetszett az az, hogy a példák megoldását nem a saját fejlesztői környezetünkkel kell megoldani, hanem az oldalba beépített emulátor segítségével. Kapunk egy "teljes" fejlesztői környezetet, editorral, debugerrel együtt, és ott kell megírni a kért feladatokat, amit a mellékelt tesztadatokon le is futtat.

Nekem nagyon tetszik ez a megoldás.

Az említett programozási nyelvek alapjai mellett algoritmusokat, matematikai problémákat illetve különféle praktikus programozási fogásokat is oktató modulokat is találunk a weboldalon. Ezek alap esetben Java nyelven oldhatók meg, de lehet választani más (PHP, C++, Python stb) nyelvek közül is.

Az oldal nyelve angol. Azt gondolom hogy aki programozásra adja a fejét és komolyan is gondolja azt, annak elkerülhetetlen az angol nyelv értő olvasása. Az oldal nyelvezete egyszerű, minimális nyelvtudással könnyen érthető. Ennyire tudni kell minden programozónak angolul.

Ajánlom az oldalt a kezdőknek és haladóknak egyaránt. A kezdők megtanulhatják az alapokat és még egy picit többet is, a haladók pedig tesztelhetik, frissen tarthatják tudásukat.

Még egy megjegyzés! Az oldal üzemeltetője a kickstarter.com-on indított egy gyűjtést az oldal fejlesztésére. Bárki felajánlhat bármekkora összeget. 4000 dollárt célzott meg ami szükséges lenne az oldal fejlesztésére, jelenleg 406$ van felajánlva. Aki teheti támogassa az oldal fejlesztését.

Helló világ!

Van egy program, amit minden C nyelvet tanulni kezdő ember megír. Ez a Hello world!
A program elhíresült és alap példává vált. Szerintem ez az a  program amit a legtöbben megírnak.
Brian Kernighan és Dennis Ritchie által írt The C Programming Language című könyv a C nyelv bibliájaként ismert. Ezt maguk a nyelv kitalálói írták és a mai napig a leghíresebb C könyv, ami minden programozónak a polcán ott kell hogy legyen, már csak tiszteletből is. Ez olyan mint a gitározásban a Hey Joe Jimmy Hendrixtől. Mindenkinek, aki komolyan gondolja...  :)

Szóval nézzük a példát:

#include
void main() {
       printf("hello world\n");
}

A programot beírjuk egy hello.c fájlba, majd lefordítjuk és futtatjuk akkor a program kiírja  a képernyőre hello world üzenetet.

Tesztnek nem rossz... :)

A C nyelvről

Én a programozást BASIC nyelvvel kezdtem. Ez egy nagyon egyszerű, magas szintű programozási nyelv volt, amivel kényelmesen lehetett megfogalmazni a programokat. A következő az assembly nyelv volt, még Z80 mikroprocesszoros gépeken.
A két nyelv között a különbség abban rejlett, hogy a BASIC nagyon egyszerű és könnyen elsajátítható volt. Rendelkezésre álltak a különféle ciklusműveletek, feltételes vezérlésátadás, szubrutinok írása és hívása. Viszont a nyelv nagyon lassú volt mivel interpretált futtatást (azaz minden programsorra külön értelmezés, fordítás, futtatás) tett lehetővé. Az assembly nyelv nagyon gyors gépi kódú programokat készítését tette lehetővé, ezzel szemben a ciklusszervezést, az utasítások sorozatát mind alacsony szinten kellett megvalósítani, ami sokkal nagyobb hibázási lehetőséget teremtett.
Később a Pascal nyelven folytattam programozói tevékenységemet, amire komoly típusosság volt jellemző és erős szigorral ellenőrzött minden egyes programsoromat.
Van egy számomra misztikus nyelv, a C nyelv, ami gyors is és magas szintűnek is nevezhető, ugyanakkor nagyon "hanyag" lazaság is jellemzi a típusszigorát.. A típusossága nagyban hasonlít az assemblyhez, a mutatók használata - ami a komolyabb programozás alapja - kényelmes. Fordítója kifejlett és gyakorlatilag assembly programot állít elő (a mai fordítók persze ezt a lépést kihagyják, de kikényszeríthető ez a kimenet is). A lényeg hogy ez a fura nyelv, a maga fura gondolkodásával igazi forradalom volt a maga idejében a '70-es évek elején. Akkoriban egy operációs rendszert készítettek a segítségével, mégpedig a Unixot, ami napjainkban is hihetetlen népszerű, hatékony és biztonságos operációs rendszer. Erre azért felkapja egy programozó a fejét. Operációs rendszert írni magas szintű nyelven? Hmmm.
Ez aztán a csemege. Így találkoztam a C nyelvvel. Akkoriban én a Pascal mellett döntöttem, mint általános célú programozási nyelv mellett. A C-be csak az egyetemi tanulmányok kapcsán merültem bele.
Szóval most elkezdenék egy újabb témát itt a Programozz! blogon. Ez pedig a C nyelv használata lesz.
Nem akarom bemutatni a különféle agyafúrt C-s pointerezést, meg az előfordító adta csodás lehetőségeket (írtak C-ben PC emulátort is, aminek forráskód hossza belefért 2000 karakterbe). Egyszerűen alapszintű megoldásokat, alap programozási feladatokat szeretnék bemutatni a segítségével.
A cikkeket a C címkével jelölöm.

Tojásrántotta algoritmusa

Az alapvető gondolkodásmód elsajátításához egy hétköznapi példa következik!
Mint korábban már többször írtam, jót tesz a megfelelő gondolkodásmód kialakításához az, ha hétköznapi tevékenységeket is "algoritmizálunk". Ennek érdekében, most tojásrántottát fogunk készíteni!

Tojásrántotta készítése

Kérdezzük meg hány tojásból készítsük a rántottát! Nézzük meg van-e annyi tojásunk, ha van akkor készítsük el, ha nincs akkor pedig jelezzük hogy nincs ennyi tojásunk.

Be: Hány tojásból készüljön?

HA van elegendő tojás AKKOR
   Törjük fel a tojásokat és tegyük tálba
   Verjük fel a tojásokat

   CSINÁLD
        Melegítsünk olajat
   AMÍG olaj eléggé forró

   Öntsd a tojást a forró olajba
   
   CSINÁLD
       Lassan kevergesd a tűzön
   AMÍG megfelelően megsül

   Tedd tányérba
   KI: A rántotta kész! Jó étvágyat

KÜLÖNBEN
   KI: Nincs ennyi tojás így sajnos nem tudom elkészíteni!

Csodálatos algoritmus! Egy nagy szelekció fogja keretbe az algoritmust (van-e elegendő tojás?) Majd a szekvenciák sorozata következik, közben két iterációval, ráadásul hátultesztelőkkel (olajmelegítés, sütés)

Erről jut eszembe egy vicc!
A programozót elküldi a barátnője boltba a következő utasítással:
- "Drágám! Menj el a boltba! Hozzál halat, ha van tojás akkor tízet!"
A programozó elmegy a boltba, majd miután bevásárolt hazajön és odaadja kedvesének a táskát, benne a bevásárolt dolgokkal. A barátnője megnézi, majd megkérdezi:
- "Miért hoztál tíz halat? És hol a tojás? Vagy az nem volt?"
- "De volt!" - mondja a programozó!

:)

Szóval a programozó mindig úgy végzi el a feladatot, ahogy az meg van fogalmazva. Abból baj nem lehet..... Legfeljebb át kell fogalmazni a feladatot, ha nem a megfelelő eredmény születik!
Gondolkozz el ezen! Hogyan kellett volna mondani a barátnőnek, hogy megértse szerencsétlen programozó, hogy mit is akar tőle a kedvese?

Legnagyobb szám kiválasztása

A következő bejegyzésben egy egyszerű algoritmust készítek el. A cél, hogy megmutassak egyfajta gondolkodásmenetet.
Elvárt ismeretek: adatbekérés, kiírás, összehasonlítás, elágazás, iteráció

Feladat: A bekért pozitív számok közül írassuk ki a legnagyobbat!

Az adatbekérést nem ellenőrizzük, feltételezzük hogy egész számokat kapunk. Feltételezzük hogy nem kell megjegyezni az összes bekért adatot.

Olvassuk el és értelmezzük a feladatot.

Mit csinálunk? Bekérünk számokat.

Mi lesz ezekkel a számokkal? Kiíratjuk a legnagyobbat.

Ez eddig elég egyszerűnek hangzik, de gondoljunk bele egy picit mélyebben. 

Hogyan határozzuk meg a legnagyobbat? Nyilván összehasonlítással.

Sorra kell vennünk az adatokat és a nagyobbat megjegyezve ismételni az összehasonlítást addig, míg az összes adatot égig nem vettük. 

Éppen ezt a tevékenységet kellene programozni!

1. az aktuális legnagyobb számnak jegyezzük meg a 0 értéket. Ennél csak nagyobbakkal kell foglalkozni.
2. Kérjük be a soron következő számot.
3. hasonlítsuk össze az aktuális legnagyobb számmal
4. ha nagyobb mint az aktuális legnagyobb, akkor felejtsük el az eddigi legnagyobbat és helyette jegyezzük meg az éppen soron lévőt legnagyobbként.
5. ha van még további bekért szám akkor vegyük a következőt és folytassuk a 2. pontnál
6. írassuk ki a megjegyzett legnagyobb számot.

Hát ennyi a teendő. Kész a program, jöhet a kódolás.
Először célszerű valamilyen szabványos általános jelölésrendszert alkalmazva a programot leírni. Később már erre nem lesz szükség egyszerűbb feladatnál, de most tegyük meg.
Picit pontosítani kell a feladatot. Honnan tudjuk, hogy van-e még további kiértékelendő szám? A feladat kiírásában az szerepel, hogy pozitív számokkal kell dolgozni. Ezért most hozunk egy olyan döntést, hogy ha 0-át kapunk kiértékelésre, az azt jelenti hogy nincs több kiértékelendő adat.
(Itt jegyzem meg, hogy az ilyen döntéseket mindig egyeztetni kell a megrendelővel és azt el kell fogadtatni vele, hiszen ő tudja hogy pontosan mit is szeretne megvalósítani!)
Ezzel a döntéssel már elkészíthető az alkalmazás.

Az adatmodell és a pszeudó nyelvű megoldás:

A REPEAT...UNTIL iteráció úgynevezett hátul tesztelő ciklus. Ez azt jelenti, hogy a ciklusmag lefutása után értékelődik ki a ciklus feltétele. Tehát a ciklusmag legalább egyszer lefut. Az UNTIL után megadott feltétel a kilépés feltétele.

Írjuk meg Pascalban ezt a feladatot:

Ennyi volt a legnagyobb számot kiírató programocska.
A feladat elején megfogalmazott ismeretek birtokában elkészíthetők az alábbi módosított feladatok is! A feladatok egyre összetettebbek, de mind megoldható szelekcióval és iterációval.
Próbálj ezek közül minél többet elkészíteni pszeudó nyelven és az éppen tanult programnyelven is (C/Pascal)
Ha elküldöd emailen a megoldást, szívesen véleményezem!

Írd át a programot, hogy kiírja a legnagyobb és a legkisebb számot is!
Írd át a programot, hogy kiírja azt is hogy hány szám lett összesen megadva!
Írd át úgy a programot, hogy pozitív számok mellett a 0 is szerepelhessen input adatként!
Írd át úgy a programot, hogy összesen 10 adatot kell bekérni és azok közül kiválasztani a legnagyobbat stb...
Írd át úgy a programot, hogy először megkérdezi, hogy hány adatot szeretnék megadni és fogadjon el negatív számokat is.

  

Programnyelvek, programozás őstörténete

Minap egy antikváriumba, megláttam egy FORTRAN programozással kapcsolatos könyvet, mely kiadásának dátuma 1970 volt. Eltöprengtem azon, hogy a könyv egy évvel idősebb nálam. Azt tudom, hogy a számítógép programozás nem éppen újkeletű dolog, de azt hogy magyar nyelvű szakirodalom már ilyen korán megjelent, nem gondoltam. (messze a PC-s korszak még, szűk réteg aki számítógéphez fér)
A könyv akkor 12 Ft volt most 275 Ft-ot kért érte az antikvárium. Gyorsan körülnéztem még és végül megvásároltam néhány régi, programozási nyelvekről szóló szakkönyvet.

Mindig is érdekeltek a különféle programozási nyelvek. Nem maga a hatékonyság, vagy a használhatóság az ami felkeltette az érdeklődésemet, hanem magának a nyelvnek a logikája, működése, szintaktikája. A régi nyelvek meg azért érdekesek, mert látni lehet a fejlődést, ahogy egyik a másikból építkezve egy újat - talán jobbat - hoz létre. Nem ismerem a régi nyelveket. BASIC majd PASCAL voltak a tanulónyelveim. Mellette kis gépikód és Assembly is adódott. Utána megismerkedtem a dBase/Clipper nyelvekkel, amik az adatbáziskezelési feladatokhoz voltak nagyszerű eszközök, majd jött a C és végül az obejktumorientált progrmaozás a JAVA, a C++ és a C# nyelveken keresztül.
Most elhatároztam hogy meg fogok ismerkedni néhány régi programozási nyelvvel. Nem feltétlenül azért, hogy használjam, hanem hogy megismerjem a programozás történelmét.

Szeretem a régi szakkönyvek előszavait, bevezető fejezeteit olvasni, mert sok érdekesség van benne. A FORTRAN könyvben is találtam egy érdekes gondolatot a programozással kapcsolatban:

"...nem a programozási nyelv oktatásáról van szó, hanem a programozási nyelvnek mint eszköznek a felhasználásával a megfelelő szaktudomány oktatásáról."

Itt arra utal a szerző, hogy egy programozási nyelv oktatása, megismerése nem azonos a programozás szaktudományának oktatásával, megismerésével.
Később ezt írja:

"A lényeges különbség a hagyományos oktatási módszerrel szemben itt az, hogy az egyes eljárásokat nem csak formulák hanem egyúttal programok formájában is megfogalmazzák. Ehhez természetesen elkerülhetetlen valamelyik konkrét algoritmikus nyelv ismerete, azonban a hangsúly nem ezen van. Ennek az  oktatási módszernek előnye, hogy a numerikus ismereteken túlmenően kifejleszti a hallgatóban az "algoritmus teremtés" készségét, amelyre egy holt képletnek élő programmá való "átvarázsolásához" van szükség. Tulajdonképpen ez az amit programozásnak nevezünk." (Lőcs-Vigassy FORTRAN programozási nyelv 6. oldal)

A gondolat nagyon sokatmondó! A Programozz! blog bevezetőjében említettem hogy ki kell alakulnia az algoritmikus gondolkodásnak ahhoz, hogy valaki tudjon programozni. Írtam ugyan itt, hogy sokan azt mondják: "Pascalban ezt simán megírom, de C-ben nem megy!"
Nos aki ezt mondja azzal az a helyzet, hogy sajnos nem tud programozni. Tud "pascalul", de nem tud programozni. Ismeri a nyelvet és az használja is, de nem tud algoritmust alkotni. Ez nagy baj! Egy programozónak a nyelv "csak" egy eszköz. A holt képletek élő programmá történő átvarázsolásához ennél több kell és ezt hívják programozásnak.

Még egy érdekes dolog, amit a könyv elszavát olvasgatva érzek. A programozás mérnöki feladat, a kódolás szakmunka. Például annak idején a programozói tevékenység nem terminál előtt zajlott, hanem programkártyákon kézzel, ceruzával írta meg a programozó a programot, majd ezt átadták a kódolónak, aki a megfelelő módon bevitte a gépbe és elkészítette a lyukkártyát, amin a betölthető programok voltak.

A példa nem teljesen "ül", hiszen itt gyakorlatilag a kódoló gépi kódra fordította (compiler) át a FORTRAN programot. Manapság a kódoláson azt értjük, hogy adott programnyelven leírunk egy algoritmust.
Ha belegondolunk mégiscsak helyes a hasonlat. Aki kódol, az egy működő modellt valósít meg. Aki programozik az magát a modellt készíti el. A kettő a programozás mai értelmében összeolvad és egyben jelenti az algoritmizálási képesség és egy programnyelv ismeretét, de a kettőt külön kell tudni választani ahhoz, hogy programozni tudjunk! Először algoritmust tervezünk, majd lekódoljuk valamely programnyelven.

Ez az átvarázsolás lesz az,  amit a programozónak tudnia kell, különben csak egy ócska bűvésztrükk betanulására és többé kevésbé sikeres bemutatására lesz képes...

Adattípusok

Már megbeszéltük korábban, hogy egy program elkészítéséhez meg kell határoznunk a bemenő adatokat és az azokon elvégzendő műveleteket annak érdekében hogy a megfelelő kimenetet kapjuk.
A bemenő adatok meghatározása egy igen fontos dolog. Egy adatot a programozás során változóként, illetve konstansként tudjuk kezelni. A változó egy oylan hivatkozás, amin keresztül elérhető és megváltoztatható az adat amit reprezentál. A konstans ezzel szemben egy fix értéket ábrázol, annak értéke nem módosítható.
Egy adatnak két jellemzője van. Az adatot reprezentáló változó vagy konstans neve és típusa.
A változó neve egy általunk szabadon választott - az adott programozási nyelv szabályainak megfelelő - karaktersorozat.
Pl.

• a háromszög oldalainak jelölésére célszerű a matematikában megszokott a, b, c változóneveket használni. 
• ha valakinek a keresztnevét szeretnénk tárolni a programban, akkor jó választás lehet a knev változónévnek.
• valamilyen indexelési műveletnél én az i és j változóneveket használom
• koordináták jelölésére természetesen az x és y nevek egyértelműek.
• irányítószám tárolása lehet az irsz változóban
• egy érték maximumát jelölheti az YMAX konstans.

Mint látható ezek célszerű, rövid a tartalmukat valamilyen logika szerint jelző nevek. A gyakorlatok során kialakul egy konvenció ami alapján elnevezzük majd a változóinkat. Használjunk rövi egyszerű, de mégis beszédes változóneveket!

A másik lényeges tulajdonsága a változóknak a nevük mellett azok típusa. A típus azért fontos mert meghatározza hogy az adott változót hogyan kell értelmezni, mik a határai, mekkora adat fér bele, azokkal milyen műveleteket lehet végezni. Pl két szöveget nagyon nehéz összeszorozni, de egy betűt egy számmal összeadni sem nagyon lehet (bár C-ben éppenséggel lehetséges :) )

Az egyszerű adattípusok azok amiket az adott nyelv eleve implementál. 

Pascal esetében a leggyakrabban használt típusok /az összes típus a nyelv referencialeírásában/:

Egészek:

• Byte: 0..255 közti egész
• Integer: -32768 .. 32767 közti egész
• Word: 0 .. 65535 közti egész
• Longint: -2147483648 .. 2147483647
• Longword: 0 .. 4294967295

Logikai típus:

• Boolean: értéke true vagy false lehet, ami  logikai igaz és hamis értékeket jelöl.

Valós típusok:

• Real: 1.5E-45 .. 3.4E38 közti valós szám
• Double: 5.0E-324 .. 1.7E308 közti valós szám
• Extended: 1.9E-4932 .. 1.1E4932 közti valós szám

Karakteres típusok:

• Char: egyetlen karakter.
• String: karakterfüzér, aminek maximális hossza 255 lehet. 

   

Kollár Zoli "hogyan kezdődött..." sztorija (I. rész)

Sziasztok!

Megosztom én is veletek a "hogyan kezdődött..." történetemet:

'83 végén, '84 elején kezdődött a számítógép iránti érdeklődésem. Ugyanis híradástechnikai szakközépiskolába jártam, és sok osztálytársammal ellentétben engem érdekelt is a szakma. Ezért a zsebpénzemet nem bulizásra költöttem, hanem alkatrészekre, újságokra. És ekkor jelent meg a '84-es Rádiótechnika évkövny, amiben elég jó leírás volt a 8085-ös mikroprocesszorról. Napokon-éjszakákon át ezerszer is elolvastam a cikket, próbáltam megérteni, hogy hogyan működik a processzor. Pár nap múlva azt vettem észre, hogy ez tök egyszerűnek tűnik. Értelmes, logikus utasítások tömkelege, amiket megfelelően sorba lehet rendezni.

'84-ben harmadikos voltam, amikor kapott az iskola egy HT1080Z számítógépet. Szó szerint az iskola kapta, mert diákok nem nagyon nyúlhattak hozzá, csak a tanárok. Ez a gép történetesen a szakmai gyakorlatot tanító tanárom asztalára került. Távolról, sóvárogva néztem a gépet...

Kaptam egy Basic könyvet kölcsön az egyik iskolatársamtól (nem a mi osztályunkba járt). Azt is hamar átolvastam és az is tök egyszerűnek tünt. Aztán egyszer megkérdeztem a tanárunktól, hogy oda ülhetek-e elé? És megengedte, a szünetekben. Mondanom se kell, hogy ezután az összes szünetet ott töltöttem a gép előtt. Első programom ha jól emlékszem egy torpedójáték volt. Aztán a Basic nem nagyon érdekelt, és közben kiderítettem, hogy a gép Z80-as processzora majdnem teljesen kompatibilis az általam már "ismert" 8085-el. Otthon papíron kezdtem el írogatni assembly-ben az egyszerűbbnél egyszerűbb programokat, a suliban már csak a lefordított kódot kellett gyorsan bepötyögni, és örülni, ha működött elsőre. Olyasmiket írtam, hogy az egész képernyőt kitölti egy karakterrel, aztán egymás után növeli őket és megdöbbentő volt számomra a Basic és a "gépi kód" közti különbség. Soha többé nem akartam Basic-et :)

'84 nyarán a telefongyárban töltöttem a szokásos szakmai gyakorlatomat és ekkor kerültem közelebbi kapcsolatba a TAP-34-es számítógéppel. Soha ennyire lelkesen nem töltöttem még szakmai gyakorlatot, mint abban az egy hónapban. Az első pár nap Star-Trekezései után nekiálltam programozni. Milyen programot is írjak? Az a gép nem volt olyan egyszerű felépítésű mint a HT, ezért eleinte maradtam a Basic-nél, és írtam egy Disassembler programot. Persze mutogattam boldog-boldogtalannak, amíg egyszer csak az ottani főnök fel nem hívta Sz. Zolit. Zoli mai szemmel rendszergazda volt egy TPA1148-as "miniszámítógépen", de ami a sorsomat meghatározta az az volt, hogy a barátnője (ma a felesége és két gyermekük anyja) a Számítástechnikai Fejlesztési Főosztályon dolgozott. Zolinak baromira megtetszett a programom, elkérte és el is kezdte terjeszeni a gyárban, mert kiderült, hogy ilyen még nem is volt a géphez.

A '84-es év további része és a '85-ös év az érettségiig nagyrészt azzal telt el, hogy kifényképeztem a HT ROM tartalmát (csak hexadecimális kódok voltak), és papírra vetettem. Ez elég sok estémet és éjszakámat emésztette fel, főként, hogy csak negatívon voltak meg a képek és diavetítővel kellett kinagyítanom. Aztán elkeztem visszafejteni a kódokat. Készült belőle egy "nyers" változat és egy "javított". Pont tele lett vele egy A4-es spirálfüzet. Ennek a munkámnak a későbbiekben igen nagy hasznát vettem.

http://ht.homeserver.hu/doc/listak/htrom/htrom.html


Alig vártam, hogy leérettségizzek és mehessek dolgozni a Telefongyárba, mivel szerződésem volt velük, hogy suli után ott fogok dolgozni. Zolival tartottam a kapcsolatot, mivel 4.-ben is a telefongyárba (is) jártam szakmai gyakorlatra év közben is, meg mint kiderült, a "Klub"-nak is meghatározó tagja volt. Legfőképp itt találkoztunk, és szóba került az elhelyezkedésem. Megkérte a barátnőjét, hogy kérdezze meg, van-e lehetőségem az ő osztályukon elhelyezkedni. És volt!

Első nap "kezelésbe" vettek az új kollégáim, akik egytől-egyig egyetemet végzett mérnökök voltak, és nem értették, hogy mit keresek én ott. T. Lajos volt az, akinek a legnagyobb hangja volt köztük, és aszondta, ha akarok egy gépet magamnak, akkor rakjak össze egyet. Ő úgy gondolta, hogy kifogott rajtam - hát nagyot tévedett! Volt ott egy prototípus TAP-34 teljesen kibelezve, és én két-három nap alatt életet leheltem bele, mindenféle segítség nélkül. Azaz ez pontosan nem igaz, mert a Floppy meghajtók működésképtelenek voltak, és ehhez segítségül kellett hívnom egy "specialistát", aki fél óra alatt beállította az elektronikát. (Akkoriban még így működtek a floppyk :)

Egy-két hétig csak ismerkedtem a géppel, a ROM-jaival, a HW elemek címzésével, működésével, a fejlesztői programokat gyűjtögettem össze, ismerkedtem az assemblerrel. A telefongyár nagyon jó hely volt, minden műszaki leírás ot volt a polcon, az eredeti Intel katalógusoktól kezdve mittudom én már, hogy mikig.

Aztán kitaláltam, hogy írok egy jobb Basic Interpretert, mint amit a Telefongyár tákolt össze. Senki nem akarta elhinni nekem, hogy képes vagyok rá. És itt jön a képbe a füzetem: visszafejtés közben meg is értettem az interpreter működését, és képes voltam szétválasztani a nyelvhez és a hardverhez kötődő részeket. (Egy kis visszaemlékezés: a suliban az egyik iskolatársamnak volt otthon egy C64-es gépe, apja olyan helyen dolgozott, ahol ez volt a munkaszköze, így azzal is volt szerencsém párszor találkozni). Nekem a C64-ből nagyon megtetszett a "Full Screen Editora", így teljesen újra kellett írni a beviteli-szerkesztési részeket. Kazettás magnó helyett Floppy funkciókat kellett írni, úgyhogy a HT kódnak (nem akarok hülyeséget mondani, de ) kb. 70-80%-át használtam fel, a többi teljesen saját kód volt. A "gyári" basic a gép rom rutinjait használta fel a képernyőre íráshoz, és az a 8275-ös CRT kontroller miatt elég lassúra sikeredett. Nekem nem is tetszett, ezért azt is teljesen újra írtam és ez volt az a része a programnak, amivel a 19.-ik születésnapomon 32.000 Ft-ot kerestem! :) A lényeg az, hogy nagyjából fél év alatt sikerült egy sokkal jobb és jóval gyorsabb Basic Interpretert írnom, és ezzel kivívnom mérnök kollégáim elismerését.

Lajos lett a "menedzserem" és elkezdte fusiban árulni a programomat. Két szervízes srác talált is rá vevőt, a szolnoki vízműveket. Egy feltételük volt, jóval gyorsabbnak kellett lennie mint a régi és kompatibilisnek kellett vele lennie.

Pont a 19.-is születésnapomon került sor a bemutatóra Szolnokon. És mekkora mázlim volt! :) Valami nyilvántartó programjuk volt, ami adatgyűjtés vagy mittomén mi közben folyamatosan írt a képernyőre ezáltal baromira lelassítva a programjukat. És mivel én átírtam a megjelenítést, így az addigi 6 óra helyett kevesebb mint két óra alatt futott le a programjuk, hibátlanul. Kérdés se volt ezután, hogy megveszik. A szerzői jogvédőn keresztül fizettek, miután mindenki levette a sápot még nekem is maradt egy otthoni számítógépre való pénzem.

Folytatása követketik...

II. rész - CP/M

A Telefongyárnak is haladnia kellett a korral, ezért mindenkinek a TAP-34-es gépét átalakították CP/M-esre. Ez nem volt különösen nagy hardverigényű "beavatkozás", egy-két fóliát kellett átvágni a CPU panelen és a ROM-okat kicserélni statikus RAM-okra. Eleinte idegenkedtem az "új rendszertől", de ez csak addig tartott, amíg az én gépemre is sor került. Egy egészen új világ tárult elém, olyan programokkal mint a WordStar, Microsoft Assembler, DDT és sorolhatnám őket a végtelenségig. Az egyik legfontosabb program a DBase volt, ami hamarosan meghatározta a jövőmet. Én képes voltam reggel 6-tól este 6-ig nyúzni a gépet, pedig hivatalosan munkám nem volt. Magyarul két és fél évig csak tanultam a programozást és a hardverekkel ismerkedtem. Sorozatban gyártottam például az ébresztős-zenélős mikroprocesszoros órákat. Fejlesztési Főosztály révén alkatrészben nem volt hiány, nem kellett elszámolni velük. 10-15 óra készült el körülbelül, az enyém még mindig megvan, bár már nem működik, mert huszonév alatt elfelejtette az eprom a tartalmát. Bár megvan még a forráskód eljárt felette az idő. Nagyon szerettem azt az órát, úgy 15 évig ébredtem a C16-ra írt Kikstart játékból "kölcsönzött" kétszólamú zenéjére. Egyébként 8085-ös proci volt benne, mert az volt a raktárban feleslegbe... A főosztályon egyetlen egy eprom égető volt, amire napokig kellett várni, hogy használhassam. Ezt is megelégeltem és csináltam magamnak :)

Aztán jött a katonaság. Én sosem éreztem magamat harcias alkatnak meg hazafi se akartam lenni, ezért próbáltam minél könnyebbé tenni magamnak azt a másfél évet, amit elvettek az életemből. Kezdtem azzal, hogy rögtön első nap a budaörsi laktanyában összefutottam K. Attilával, aki szintén telefongyári és jó haverom is volt. A vállapján több csillag volt mint az égen :) Kiderült, hogy az egyik alezredes feleségénél dolgozik a számítógépteremben. Aztán még aznap elvittek debrecenbe egy hónapra kiképezni. Csakhogy én szemüveges vagyok és ezért "B" kategóriát kaptam. Ezzel nagyjából három hetet át is vészeltem - se lövészet, se sárban csúszkálás, se konyha -, mígnem valamelyik nagytudású őrvezetőnek eszébe nem jutott, hogy nem a szívemmel van baj :(

Ezalatt az egy hónap alatt se tétlenkedtem a programozással: a telefongyárban megismerkedtem egy furcsa viselkedésű sráccal, R. Palival. Szakmáját tekintve vegyész volt, de őt is inkább a számítógépek érdekelték és volt tehetsége hozzá. Nem nálunk dolgozott, hanem egy másik osztályon, de senki nem tudta megmondani, hogy neki igazából mi is a munkája. A lényeg az, hogy másik munkahely után kezdett nézelődni, és saját fejlesztésű CP/M-es gépet tervezett az oroszoknak. A termináljába a már említett 8275-ös CRT kontroller került, amit szerintem addigra magyarországon én ismertem a legjobban. Papíron, egy kockás füzetbe megírtam a terminál teljes programját, többször "lefuttattam" fejben. Mikor visszakerültem Budaörsre és kiengedtek pár napra, első utam Palihoz vezetett, ahol még aznap éjszaka beírtuk a programot. Kisebb javítások után kifogástalanul működött :)

Visszatérve a laktanyába a századparancsnok irodájában találtam magamat. Tényleg százados volt és pontosan olyan vörös volt a feje mint a szovjet zászló. Azt kérdezte (inkább üvöltötte), hogy miért nem jó nekem ott, miért kell nekem hátszél, miért akarok máshová menni? Fogalmam se volt róla, hogy miről beszél. Még aznap kiderült, hogy Attila - akivel első nap összefutottam - "intézkedett", és az alezredesnél találtam magam, mint "személyi programozója". Egy C128-as gépe volt neki, amin futott a CP/M, és meg volt neki minden programja, ami szükséges lehetett. Úgyhogy DBase tudásomat felfrissítve mindenféle nyilvántartó programokat írkáltam neki - amikor épp nem játszottam :) Cserébe csak hétköznap reggel 7-től délután 4-ig kellett a laktanyában lennem, úgyhogy király életem volt. Ezért említettem korábban, hogy fontos dolog volt az életemben a DBase.

A folytatásban az első PC-m építése következik...

Programozási nyelvek, értelmezők és fordítók

Itt az idő hogy konkrétan belevágjunk a programozásba és igazi programot készítsünk, igazi exe-t amit tudunk futtatni (PC és Windows esetében).
Ahhoz hogy a megalkotott programokat a gép számára is érthető és végrehajtható formába öntsük, szükség van egy eszközre ami ezt megteszi. A valamilyen programozási nyelven megírt programunkat a gép számára érthető gépi kódra kell fordítani. Alapvetően kétféle megvalósítás létezik. Az egyik az értelmező (interpreter) a másik a fordító (compiler).
Röviden összefoglalva az interpretrek jellemzője hogy a forrásprogram utasításait akkor fordítja le amikor végre kell azt hajtani, míg a compilerek az egész forrásprogramot lefordítják gépi kódra, majd a linkelés után (ezt szintén nem szeretném most részletezni) létrejövő programfájl (exe) már közvetlenül futtatható.

Ebben a blogban a manapság leggyakrabban alkalmazott nyelveket, a C és a PASCAL nyelvet fogom példaként használni. A két nyelv között nagyon sok elvi különbség van. Szinte vallási fanatizmussal vetekszenek a különböző felfogások. "Miért jobb a C mint a Pascal?" típusú kérdések köré már filozófikus mélységű elemzések és eszmefuttatások kötődnek.
Jelenleg részünkről a különbség a jelölésmódban áll. Gyakorlatilag a C hardverközelibb, a Pascal meg szigorúan típusos és sokkal szebb, tisztább, olvashatóbb kód készíthető vele. De nem akarok belemenni most az ilyen szintű elmélkedésekbe.

Windows alatt Pascalhoz a Free Pascal környezetet ajánlom, C-hez pedig a Code::Blocks fejlesztőkörnyezetet. Ha a telepítésekkel probléma van írjatok! Mindkét fejlesztőeszköz ingyenesen és legálisan használható.

Ismerkedés a C#-al és a .NET Framework-el

Mivel ősztől az egyetemen .NET programozás kapcsán a C# nyelvet fogjuk tanulni, ezért egy picit elébe megyek a dolgoknak és elkezdek ismerkedni ezzel a nyelvvel és a platformmal.
Itt a blogban a C# és .NET cimkékkel ezeket a bejegyzéseket fogom jelölni.
Alapjaiban az egészet talán onnan érdemes megközelíteni hogy a Sun megtiltotta a Microsoftnak hogy a nagy sikereket elért JAVA-t a - JRE-t és a JDK-t - beintegrálja a Windows XP telepítőkészletbe. Ezért a Microsoft elkezdett fejleszteni egy hasonló dolgot mint a Java. Azaz egy virtuális gépet, egy programozói és egy futtató környezetet jól kidolgozott és átgondolt osztályhierarchiával. Ez lett a .NET Framework. A nagy különbség hogy ez szinte minden most futó windowson integrált része az operációs rendszernek, így mindenhol rendelkezésre áll, míg a Javát telepíteni kell (ez sem ördöngősség, de mégis foglalkozni kell vele). A másik különbség, hogy ugyan platformfüggetlennek tervezték a .NET-et de gyakorlatilag csak a Microsoft rendszereiben valósult meg (vannak kivételek MONO, vagy a DOTGNU).
Segítségével gyors és hatékony Windows programokat lehet készíteni a legmodernebb technikákkal.
A .Net-et jellemzően a C# nyelvvel lehet programozni, de a Visual Studio össze eszköze már erre is használható (Visual Basic.NET és a J#).
A C# - ez a blog alapja végülis - egy C++ szerű teljesen objektum orientált programnyelv. Nagy hasonlóságok fedezhetők fel a Java nyelvvel való összehasonlítás kapcsán.

Az adatok

Az algoritmusok utasítások sorozata, melyet az adott programozási nyelv lehetőségeit és eszközkészletét felhasználva a bemenő adatokból a kívánt kimenetet adja.
Beszéltünk már a strukturális programozás vezérlési szerkezeteiről. Ezek utasítások, azok ismételgetése stb. Az utasítások azonban adatokon dolgoznak. De mik ezek az adatok? Milyen típusai vannak? Számít-e a típus? Ezek a kérdések felmerülhetnek az adatokkal kapcsolatban.
Először próbáljunk felsorolni néhány adatot.

• a háromszög oldalának hossza
• a felhasználó neve
• a kedvenc színünk

Ezek az adatokat a számítógépen kezelnünk kell tudni. Ehhez az kell hogy a számítógép tárolni (ábrázolni) tudja ezeket. Az adatok egyik legfontosabb tulajdonsága a típusa. Ez határozza meg hogy az adatokkal milyen műveleteket tudunk végrehajtani, illetve adott műveletek eredménye milyen típusú adatot szolgáltat.
Az alapvető típusok:
egész számok
lebegőpontos számok
karakter
szöveg
logikai érték
A programozási nyelvekben általában ezek rendelkezésre állnak és ráadásul többféle megvalósításban. Ugyanis a típus mellett a másik fontos tulajdonsága az adatoknak az ábrázolható tartomány. Egész szám pl az 5 vagy a -531, de a 1232145 is. A különböző megvalósítások általában figyelembe veszik hogy pozitív számokat vagy előjeles számokat akarunk tárolni. A tárolás alapegysége a byte, ami 8 bitet jelent. Ezen a legnagyobb ábrázolható pozitív egész szám a 255. Ennél nagyobb számokat úgy tudunk ábrázolni ha több bájtot összefogunk. Ugyan ez érvényes a lebegőpontos számokra is, amik ráadásul speciálisan vannak tárolva (ezzel nem akarok most itt foglalkozni). Egy karaktert ASCII kódjával tárolunk, ami 0-255 közötti egész szám. Egy szöveg több karakter egymás után írása, azaz karaktersorozat. Ezt annyi bájton tároljuk ahány karakterből áll és speciálisan tárolni kell a hosszát, vagy jelölni kell a végét.

Egyelőre ennyit az egyszerű adattípusokról. Apropó! Ugyanis vannak összetett adattípusok is, de erről kicsit később beszélünk.

A vezérlési szerkezetek

Az előző cikkekben volt néhány nagyon egyszerű példa, amiknek a szerkezete valami ilyesmi volt:
START -> ADATBEKÉRÉS -> MATEMATIKAI MŰVELETEK -> ADATKIÍRÁS -> STOP

Az ilyen szerkezetet hívják szekvenciának, azaz sorozatnak. Elkezdődik valahol és egyenesen elágazás nélkül halad a cél felé. De mi van akkor ha nem ilyen egyértelmű a dolog? Mondjuk ellenőrizni kell valamit és az ellenőrzés eredményétől függően halad tovább a végrehajtás? Mondjuk ellenőrizni akarjuk a háromszög kerületszámoló programunkban, hogy a megadott oldalhosszakkal valóban lehet háromszöget rajzolni. (ezt a példát is meg fogjuk később csinálni)
A másik probléma az hogy mit csináljunk akkor ha egy adott tevékenységsorozatot többször végre kell hajtani? Például ki akarjuk íratni a számokat 1-100 között. Persze megcsinálhatjuk úgy is hogy írunk 100 db kiírató utasítást, csak egyrészt ez nem igazán programozás, másrészt ha vizsgán ilyet csinálnál akkor gondolkozás nélkül vágnának ki, pedig működik a program.....


Ezeket a fentebb vázolt dolgokat nevezik vezérlési szerkezeteknek. Ezeket tekintjük most át.
Egy programozási nyelv vezérlési szerkezetei (és adatszerkezeti) határozzák meg hogy az adott nyelvven milyen stílusú programozás valósítható meg. A legáltalánosabban használt programozási módszer a struktúrális programozás. Ennek lényege hogy szekvenciákkal (soronkénti végrehajtás), iterációkkal (ciklusok szervezése) és szelekciókkal (feltételes elágazások) minden probléma megoldható.

• Szekvencia: utasítások egymásutáni végrehajtását jelenti elágazások és ismétlések nélkül.
• Szelekció: egy logikai feltétel eredményétől függően elágazik a program végrehajtása.
• Iteráció: egy logikai kifejezés eredményétől függően ismételten végrehajtunk egy programrészt.Ezt nevezzük ciklusnak is.

Ezeket nézzük meg hamarosan részletesebben.

Írjuk le saját szavakkal a programot

Megkérdezheted hogy mire jó ez az egész, hogy ilyen baromságokkal foglalkozom és nem valamilyen programnyelven keresztül mutatom be a programozást. Nos a válasz az, hogy mellékes dolog az ha egy problémát leprogramozol (meghatározod az input és output adatokat, a rajtuk végzendő műveleteket) azt milyen eszközzel jegyzed le. Az elején ha elkezdjük egy adott jól ismert programnyelv használatát, akkor arra fogunk koncentrálni, hogy a nyelvnek mik a lehetőségei, milyen korlátai vannak, mik a szabályok amit be kell tartani, előtérbe kerül maga a fordító program is és elveszik a lényeg: a programozás, az algoritmizlás, az analizálás az optimalizálás. Pedig a lényeg éppen ez. Nem az a fontos hogy milyen eszközzel jegyezzük le a programot, hanem az hogy meg tudjuk fogalmazni magunknak, rendszerezni tudjuk és logikus érthető formában álljon rendelkezésre. A későbbiekben nem fogod természetesen lejegyezni így a programterveidet, de most az elején szükséges hogy ennek segítségével a lényegre koncentrálj.


Ha meg tudod fogalmazni egyszerű mondatokkal az elkészítendő programot, akkor a nehezén túl vagy. Ebben kell gyakorlatot szerezni, aztán a kódolás már gyerekjáték lesz.

Absztrakció - lépjünk közelebb a kódoláshoz

A programozással készen is vagyunk. Ha meg tudsz fogalmazni ilyen módon problémákat (bemenet, kimenet, adatok, műveletek) akkor már tudsz programozni. Nagyon fontos hogy leírd ezeket, mert különben azt hiszed hogy tudod és mikor vizsgán valóban adoptálni kell akkor meg lesünk ki a fejünkből és nem tudjuk miért nem megy.
Szóval még néhány példa:

Két bekért számról döntsük el hogy mennyi a különbségük. Ezt írjuk is ki.

Kérjük be az első számot (SZ1)
Kérjük be a második számot (SZ2)
Vonjuk ki az elsőből a másodikat, majd vegyük annak abszolút értékét. (K=ABS(SZ1-SZ2))
Írjuk ki a különbséget (K)

Kérjük be egy személy születési évét, majd írjuk ki hogy hány éves:

Kérjük be a születési évet (SZULEV)
Vonjuk ki az aktuális évből a születési évet és tároljuk (KOR=YEAR()-SZULEV)
Írjuk ki a kiszámolt értéket (KOR)

Nem ragozom tovább.
Mint láthatod vannak általában használható egyéb műveletek is. Ilyen az ABS() és a YEAR(). Ezek olyan dolgok amit feltételezünk hogy rendelkezésre állnak. Mindig utána kell járni hoyg valóban léteznek-e. (Nekünk a Széchenyi Egyetemen egy absztrakt pszeudó nyelvet találtak ki és abban léteztek ilyen funkciók. Ezt ki is emelték és alkalmazhattuk! A dokumentációban szerepelt.)

És akkor nézzünk egy picit absztraktabb úgynevezett pszeudó nyelven megfogalmazott példát.
Először természetesen a kerületszámoló algoritmust nézzük:

Be: A
Be: B
Be: C
K<- A+B+C
Ki: K

Két szám különbsége (fenti első példa):

Be: SZ1
Be: SZ2
K<-ABS(SZ1-SZ2)
Ki: K

Életkor kiírása:

Be: SZULEV
KOR<-YEAR()-SZULEV
Ki: KOR

Hú mennyi programot írtunk hirtelen.....
Ezek nagyon egyszerű dolgok, de ne felületesen kezeld ezeket. Legalább 10 problémát keress, fogalmazd meg és írd le ilyen pszeudó kóddal.
Eleve az hogy keresel magadnak feladatot az is nagyon sokat segít, hiszen már analitikusan vizsgálod a körülötted lévő világot. Azon gondolkodsz vajon mi az amit ilyen módon algoritmizálni lehet?

Első program

Az első postban írtam hogy életem első önálló programja egy háromszög kerület számoló program volt. Hogyan is nézett ki ez a program? Íme:

Kérd be az A oldal hosszát (A)

Kérd be a B oldal hosszát (B)

Kérd be a C oldal hosszát (C)
Számold ki a kerületet (K=A+B+C)
Írd ki a háromszögkerületét (K)

Ennyi. Ez azon lépések sorozata mely a bemeneti adatokon műveletek elvégzése után a kívánt kimenetet adja.
Szerintem másra számítottál. Talán valamiféle programnyelven (Pascal, C, Basic) elkészített forrásszövegre. Nos ez az utolsó ám nagyon fontos lépés lesz!
A programozáshoz először egyfajta gondolkodásmódot kell kézség szinten elsajátítani.
Egyetemi tanulmányaim során találkoztam azzal a megdöbbentő ténnyel, hogy a mérnök informatikus szakra jelentkező hallgatóknál ez a gondolkodásmód nincs meg. A kb 60 fős induló évfolyamlétszámból a negyedik félév végére négyen maradtunk. A bukások két tárgyra vezethetők vissza. A programozásra és a matematikára. Mindkettő alapvetően fontos a programozáshoz.
A rendszerszemlélet, az algoritmizálás, az alapvető optimalizációs készség és egyáltalán az alapvető algoritmusokban való tájékozottság. Nem az algoritmus ismeretéről beszélek, hanem arról hogy tudjon róla  a programozó hogy létezik, találja meg és tudja értelmezni, alkalmazni algoritmizálni.
Ezek az alapvető dolgok amik ahhoz kellenek hogy valaki programozni tudjon. Persze ezek a készségek is "feltuningolhatók" vizsgaidőszakra és a sok gyakorlás amolyan készséggé tud átmenetileg alakulni. Ha pedig nem marad abba a gyakorlás akkor előbb-utóbb rögzül, reflex-é válik. Ezzel csak azt akarom mondani, hogy fel tudsz készülni a vizsgára! Kellő szorgalommal és rendszerességgel nem lehet probléma.

Elemezzük a háromszög kerületszámító problémát a Program számítástechnikai értelemben című cikkemben megfogalmazottak szerint!
Input adat: három input adatunk van. A háromszög A, B és C oldalának hossz.
Output adat: a háromszög kerülete, amit megjelenítünk
Művelet: egy picit több van mint elsőre gondolható. A triviális művelet a háromszög kerületének kiszámítása. Ez egy összeadás, ráadásul nem is egy, hanem kettő (két összeadás jel van) és rögtön értékül is adjuk az eredményt (egyenlőségjel). Ezek mellett tekintsük műveletnek, vagy tevékenységnek az adat bekérést (ebből három van) és az adatkiírást (ebből egy van).
Van három bemenő adatunk amit bekérünk egyesével, elvégezzük a számítási műveletet,majd megjelenítjük a kiszámolt kerületet.
Csupán annyit tettünk, hogy a teljesen természetes módon keletkező gondolatainkat megfogalmaztuk mondatokba és azt leírtuk. Azaz nem csupán végrehajtottuk a bemagolt formulát, ami így szól: "ká egyenlő á plusz bé plusz cé" hanem azt átírtuk matematikai formába K=A+B+C. Mivel szükségesek az oldalhosszak a képlethez ezért azokat meg kell tudnunk, azaz be kell kérnünk. Ezt is megtettük. Leírtuk hogy kérjük be. Hú de triviális ugye! Nem tettünk semmi csodát, csak leírtuk....
Picit gondolkozzatok el ezen, hogy mennyire gáz ez az egész és mennyire egyszerű is ez.

A program (számítástechnikai értelemben)

Próbáljuk megfogalmazni az előző általánosítás segítségével a számítástechnikai program fogalmát. Valahogy így szólhat:

A program olyan lépések sorozata, mely egy előre kigondolt, megtervezett műveletsorozat végrehajtásával a bemenő adatokból valamiféle kimenetet ad.

Nézzük csak az új fogalmakat.
Műveletsorozat. Programozásban elsősorban matematikai műveletekre kell gondolni, de ilyenek a nem szám jellegű adatokon végzett tevékenységek is. Hogy érthető legyen gondolj pl egy név megkeresésére egy adathalmazban. A keresés is egy művelet, de nem számokon alapszik. Vagy egy másik példa: a "Helló világ!" szöveg első három betűjének lekérdezése is egy művelet. A lényeg hogy valamiféle adaton értelmezett tevékenység.
A művelet mellett az adat a másik fogalom amit ismerni és tudni kell értelmezni ha programozást szeretnénk tanulni.
Az adatot fogjuk fel úgy hogy nem más mint egy információ, számítógépen ábrázolt és értelmezhető formában.
Művelet és adat egymástól elválaszthatatlan dolog a programozásban. A program adatokkal dolgozik. Adat nélkül nincs értelme a programnak. Az adatokon műveleteket hajtunk végre. Ha nincs adat akkor a műveletnek sincs sok értelme. Gondoljunk csak bele.Mit csinál az a program amiben nincs adat? Próbáljunk kitalálni egy ilyet. Nagyon nehéz.... Szinte lehetetlen...
Nincs olyan program amiben nincs adat és nincs olyan program, amiben nincsenek műveletek.
Picit összemosódott a program és a művelet fogalmak. Ez nem baj, hiszen a program nem más mint műveletek sorozata, tehát ha úgy tetszik egy összetett művelet (....ami természetesen adatokon dolgozik...)
Adós vagyok még két fogalommal a fenti meghatározásból. Bemenet és kimene.
A bemenet a mosógépes példa esetében a piszkos ruha, a kimenet pedig a tiszta ruha. Éppen ez volt a célunk. A bemenő adatokon (piszkos ruha) végrehajtottuk lépésről-lépésre a műveleteket (áztatás, mosás, centrifugálás) és megkaptuk a kimenetet/kimenő adatot (tiszta ruha).
A bemenetet az idegennyelvű szakirodalom inputnak a kimenetet outputnak nevezi.
Tartsuk ezeket a fogalmakat szem előtt mindvégig. Értsük és tudjuk hogy mit jelentenek pontosan!
Bement (Input), Kimenet (Output), Művelet, Adat, Program