2012. június 7., csütörtök

Elágazás

A ciklusok után jöjjenek most az elágazások és akkor már tisztában lesztek a (nagyon) alapokkal. Mire jó az elágazás? Arra, hogy bizonyos dolgokra valamitől függően, másként reagálhassunk. Ha anyukád megkérdezi, hogy van e még otthon tej, az egy elágazás. Te mondhatod, hogy van, vagy azt, hogy nincs, attól függően, hogy találtál e tejet a hűtőben. Az elágazás az egy döntés, vagyis logikai (boolean) változóra van szükség a használatához, bár ez nem teljesen igaz, bármilyen feltétel jó, aminek a végén egyértelműen igaz, vagy hamis eredményt kapunk. Na, de ez egy kicsit érthetetlenre sikerült ahogy nézem, ezért inkább nézzünk egy példát.

if(5>3) //a reláció értéke igaz, true, 1
{
cout<<"Igaz";
}

Ez egy nagyon egyszerű elágazás volt. Az "if'" azt jelenti angolul, hogy "ha", vagyis ha le akarjuk fordítani a fenti feltételt, akkor azt mondhatjuk, hogy "ha 5 nagyobb, mint 3 akkor...". Ezután jön a kapcsos zárójel. Az ebben lévő kód akkor fordul le, ha a zárójelben lévő kifejezés igaz. Jelen esetben az 5 mindig nagyobb, mint a 3, ezért mindig le fog futni, ami kapcsos zárójelben van. Mi van akkor, ha mégsem teljesül a feltétel? Nézzük meg!

if(1>3) //a reláció értéke hamis, false, 0
{
cout<<"igaz";
}
else
{
cout<<"hamis";
}

Most 1 van az 5 helyén, ami viszont már kisebb, nem pedig nagyobb a 3nál. Ezért az első kapocsban lévő ág nem fog lefutni. Viszont az "else ág" le fog futni. Most már tényleg meg tudjuk mondani, hogy van e tej, vagy nincs. Igazából ezek a programozás alapjai: változók, vezérlési szerkezetek (ciklusok, elágazások). Ezekkel már elég sok mindent meg tudtok csinálni. Egyébként az elágazásokat direkt írtam többesszámban, ugyanis nem csak a fenti példákban bemutatottak léteznek. Else helyett például lehet használni, "elseif()"et, ami annyit jelent, hogy ha az első feltétel nem teljesül, akkor újra megnézzük a kifejezést és még egyszer megvizsgáljuk, de ezúttal másra.

if(x>3) //a reláció értéke hamis, false, 0
{
cout<<"Nagyobb mint3";
}
elseif(x==2)
{
cout<<"Je, ez 2";
}
elseif(x<2)
{
cout<"kisebb mint 2";
}

Így egymásba lehet ágyazni a feltételeket elég hosszan. Ez mondjuk egy picit értelmetlen példa volt most, de csak az "elseif()"et akartam bemutatni. A reláció értéke ugye az x változótól függ, ha az 5, akkor az első ág fut le, ha 2, akkor második, ha mondjuk 1, akkor pedig a harmadik. Ezen kívül is még ott van a Switch szerkezet, ami hasonló az elseif() funkciójához.

switch ("two")
{
case "three": cout << "3";
    break;
case "two": cout << "2";
    break;
case "one": cout << "1";
    break;
default: cout << "kutyus";
    break;
}

Ezt meg lehetne csinálni sima elágazásokkal is, de így szebb. Az elágazásunk megkapja a "two" értéket, majd megkeresi a lehetőségek között és ahol megtalálja, az az ág fog lefutni, vagyis most 2-t fog kiírni. a "default" azért van ott, hogy ha mondjuk olyan értéket kap a Switch, ami nincs felsorolva (esetünkben mondjuk, "ten"), akkor a default ág fog lefutni.
Ez most egy rövid és kicsit összecsapott bejegyzés lett, ha nem érhető valami, nyugodtan lehet kérdezni.

2012. március 13., kedd

Linux vs. Windows

A minap kaptam egy kisebbfajta oltást egyik csoporttársamtól, amikor látta a laptopomat. Az oltást nem a laptop miatt kaptam, hanem az azon futó operációs rendszer miatt, ugyanis Linux futott rajta éppen. Van a gépemen Ubuntu Linux és Windows 7 is, de mostanában inkább a Linuxot használom. Először csak a kíváncsiság hajtott a pingvin felé, hogy próbálgassam mit tud és mit nem. Viszont később egyre jobban hozzászoktam és rájöttem, hogy sokkal jobban szeretem, mint a Windows-t. Persze ezért is hülyézve lettem, mert csoporttársam szerint a Linux nem jó, a Windows a jó...hülye vagyok, stb. Persze megindokolni nem igazán tudta a dolgot, nem mintha ez meglepő lenne. Nem tudom, hogy miért táplálnak sokan negatív előítéletet a Linux-ok felé. Szerintem az Ubuntu egy kifejezetten felhasználó barát, könnyen kezelhető rendszer lett. Szép, csicsás, egyszerű, kényelmes, minden megvan benne, ami kell. Ráadásul szól még mellette pár másik érv is.

Linux +

1. Teljesen ingyenes. Mindemellett jár hozzá még egy csomó ingyenes program és a szoftverközpontnak köszönhetően nagyon könnyen be tudunk szerezni további programokat.

2. Pendrive-ról könnyen telepíthető. Ennek igazából a nagyobb előnye az szerintem, hogy mivel van Pendrive-ról futtatható verziója, így ha valami van a gépünkkel és esetleg nem akar elindulni az operációs rendszerünk, legyen az pingvin, vagy esetleg ablakok, akkor még mindig van egy operációs rendszerünk. Beröffentjük pendrive-ról a Linux-ot és vagy kijavítjuk vele a hibát, vagy épp megmentjük adatainkat és aztán újratelepítjük a gépet.

3. Nekem, ami még nagyon tetszett, hogy sokkal jobban felismerte a laptopomban lévő hardwaver-eket, mint a Windows. Itt nem kellett driver-eket telepítenem, míg Windows-on azért elszenvedtem egy darabig, mire minden normálisan működött.

4. Rendezettebb, logikusabb, mint a Windows. Legalábbis szerintem.

5. Jelentős sebesség/teljesítmény növekedés Windows-hoz képest. Nálam a Windows-ra fél éveket kellett várni, mire elindult és még utána is elég döcögősen működött egy darabig. Ráadásul nálam valamiért a Windows folyton csak Force Shutdown-al akart leállni. A Linux viszont gyorsan beindul, menet közben is szépen tartja magát. Ráadásul szépen ki is kapcsol, ahogy kell.

6. Ami van Windows-ra, azoknak a nagy része bizony már van Linuxra is. Legalábbis nekem eddig nem volt olyan problémám, amit ne tudtam volna megoldani. Olyanért sem szitkozódtam még, hogy "bezzeg ez Windows-on csak két kattintás lenni, itt meg szenvedek". Sőt, éppen ellenkezőleg, nekem Linux-on egyszerűbbnek bizonyult az élet. Például, ha találkozom egy új fájlformátummal, akkor Windows-on általában google-t nyit az ember és böngészget, keresgél, majd letölt valami programot. Linux-on ez két kattintás, ott van a szoftverközpont, beírjuk a fájlformátumot és már jön is lefelé, ami kell hozzá.

7. Nem kell annyira rettegnünk a vírusoktól, mint Windows-on.


Linux -

1. Nálam valamiért gyakran (ezt ne úgy értsétek, hogy gyakran...hanem csak gyakrabban, mint Windows-on) előfordul, hogy beszaggat a youtube. Szóval a flash-el néha van egy kis bakija. Ez persze csak egy kis apróság és valószínűleg orvosolni is tudnám a problémát, ha nem volnék ennyire lusta.

2. Kikapcsolásnál nekem néha behülyül és a kikapcsolás képernyő kicsit szétesik. Persze ez csak egy pici szépséghiba és amúgy is csak ritkán jelentkezik.

3. Lassú a hibernálás. Windows-on én általában hibernáltam a gépet, viszont Linux-nál, mintha ez több időt vett volna igénybe. Ezért mostanában kikapcsolom inkább.

4. Rossz akkumulátor idő jelzés. Ez nálam folyton bakis. Múltkor teljesen fel volt töltve a laptopom, levettem töltőről és azt írta, hogy 65%on van. Aztán a hátralévő idő, folyton ugrált. Visszaraktam töltőre, elkezdte írni, hogy mennyi idő, amíg feltölti. Először 1 órát írt, majd később többet. Nem tudom, hogy mi a baki oka, de minden esetre érdekes.

5. Nem tudjuk elütni az időt kedvenc Windows-os játékainkkal.


A Windows-t ennyire nem fogom kifejteni, azt úgyis ismeri mindenki.

Windows +

1. Mindenki ismeri, hozzászokott az idők folyamán, ezért kezelése egyszerű.

2. Mindig igyekszik szép és csicsás lenni.

3. Vannak rá játékok.

Windows -

1. Fizetős, drága.
 
2. Rengeteget eleszik gépünk erőforrásából, szinte már élősködik.

3. A fenti miatt, igencsak tudja lassítani gépünket.

4. Sokszor macerák vannak a driver-ek telepítésével.

5. Mivel sokan használják, sok vírus van rá.

Tudom, hogy nem lett éppen egy szakmai írás, de azért talán sikerült leírnom a lényeget, persze a teljesség igénye nélkül. Ezt amúgy is csak egy gyors bejegyzésnek szántam. Később talán még írni fogok egy kicsit a Linux-os programokról is. Konkrétan arról, hogy mi az, ami van Linux-on és Windows-on is és hogy mi az, ami ugyan nincs Linux-on, de helyettesíti a Windows-os megfelelőjét. Ti pedig írjátok meg, hogy milyen operációs rendszert használtok és miért.

2012. február 24., péntek

Rendszerváltás

Ezt a bejegyzést most teljes egészében a másik blogomról másoltam be ide. Viszont úgy néz ki, hogy egy kicsit részletesebben fogok foglalkozni a Linux témával és azt majd inkább itt teszem. Előző félévben a suliban kaptunk egy kis alap fejtágítást a Linuxról. Bevezetés a számítástechnikába órán mindig Debian Linux-ot kellett használnunk és megismerkedtünk az alap szöveges parancsokkal és a rendszer felépítésével. Pár bejegyzés keretében ezeket szeretném majd saját magam számára feleleveníteni és veletek megosztani.

Egy majdnem hirtelen ötlettől vezérelve, ma fogtam a laptopom és szépen leformáztam az egészet, majd a Windows 7 helyett, feldobtam egy Ubuntu Linux-ot. Azért mondom, hogy majdnem hirtelen volt az ötlet, mert ősszel is ezen gondolkodtam. A suliban bevszámtech órán kötelezően Linux-ot kellett használnunk és nekem akkor eléggé megtetszett a dolog. Szóval már ki akartam próbálni egy ideje élesben is a dolgot. Nézegettem is különböző pendrive-ról is futtatható Linux disztribúciókat, aztán valahogy megállapodtam az Ubuntu-nál. A végén mégse raktam fel, nehezen ment az elszakadás a már megszokott Windows-tól. Viszont már eléggé le volt fáradva a laptopom és ezért ráfért volna egy teljes újratelepítés. Aztán meg, ha már telepítek, akkor gondoltam nézzük élesben is a Linux-ot, ha tetszik, akkor maradhat, ha nem, akkor vissza Windows. Kicsit nehézkesen ment a partíciós tábla normális létrehozása, ráadásul, hogy akartam egy kis plusz helyet is hagyni, hogy esetleg két operációs rendszert is fel tudjak tenni. Miután ez összejött, elindult a telepítés. Szerencsére nem tartott túl sokáig, kényelmesen elmosogattam és mire visszajöttem, már kész is volt. Miután végzett a telepítő, kért szépen egy újraindítást, amit meg is kapott. Ezek után már hiba nélkül észlelte a gépemben lévő alkatrészeket és fel is ajánlotta, hogy letölti nekem a megfelelő illesztőprogramokat. Miután ez is megvolt, kért egy újabb újraindítást, hogy életbe léphessenek a változtatások. Ezt is engedtem neki. Viszont ez után jött a vicces dolog. Kidobott egy olyan hibát, hogy valamelyik boot fájl megsérült és ezért a Ctrl+Alt+Del kombináció segítségével indítsam újra a gépet. Ezt meg is tettem, úgy körülbelül harmincszor. Miután meguntam, teljesen áramtalanítottam a gépet és úgy próbálkoztam. Kicsit meglepődtem, amikor bekapcsoltam a gépet és nem történt semmi. A gép ment, de a képernyő teljesen sötét maradt, nem történt semmi. Még a BIOS-ba se tudtam belépni, semmibe. Ezt a ki-be kapcsolgatást is megcsináltam párszor, de nem volt semmi hatása. Gondoltam kicsit hagyom pihenni és addig inkább eszek valamit. Ez meg is történt és miután újra próbálkoztam, már beindult mindenféle gond nélkül. Nem tudom, hogy mi nyűgje volt, vagy milyen boot fájl hiányzott neki, mert utána arról már nem kaptam semmilyen üzenetet és azóta szerencsére minden megy zökkenőmentesen. Most jön majd az a rész, hogy az üresen hagyott partícióra megpróbálok felrakni egy Windows 7-t. Tudnék örülni, ha összejönni. Ha nem sikerül, akkor meg tesztelgetem még egy kicsit a Linux-ot és vagy marad, vagy nem. Talán még írok majd a fejleményekről, bár nem tudom, hogy hány olyan ember olvassa a blogom, akit esetleg érdekel is ez a téma.

Íme egy Ubuntu asztal

2012. február 8., szerda

Ciklus, mert a jó dolgokat meg kell ismételni

No, végre elkezdtem folytatni ezt is. A mai tananyag pedig a különböző ciklusokat taglalja majd, amik arra jók, hogy egyszerűen meg tudjunk ismételni -akár elég sokszor is- bizonyos kód részleteket. Háromféle ciklust fogunk venni, melyek a következők: elől tesztelő (while), hátul tesztelő (do while), számláló (for).
Kezdjük is egyből a while ciklussal. A feladat majdnem ugyanaz, mint a legutóbb, csak most nem egyszer fogjuk kiíratni a "Hello World!" szöveget, hanem tízszer. Vágjunk is bele, íme a kód:

#include<iostream>
using namespace std;
int main()
{
    string szoveg; //kérünk egy szöveg változót, ahogy a legutóbb
    szoveg="Hello World!"; //rakunk bele szöveget, ebben sincs semmi új
    int i=0; //létrehozunk egy egész típusú változót, melynek egyből értéket is adunk, méghozzá a nullát
    while(i<10) //jön a ciklus, zárójelben megadjuk, hogy meddig menjen. Addig meg amíg i<10
    {
        cout<<szoveg<<endl; //kiírjunk a szöveget, majd az "endl" utasítással átugrunk a következő sorba
        i++; //megnöveljük az "i" értékét egyel, hogy majd egyszer nagyobb legyen 10nél
    }
    return 0;
}

Ugyan kommenteltem, de azért most magyarázok még egy picit. Az "i" értéke először nulla, ezért a ciklusunk lefut (gondolom mindenkinek egyértelmű miért...a 0 kisebb, mint a 10). A ciklusunkban megnöveljük az "i"-t, így az értéke már 1 lesz, ami viszont még mindig kisebb, mint a 10. Ez így fog menni, amíg az "i" értéke 10 nem lesz, ugyanis a 10 már nem kisebb, mint a 10. Ugye milyen egyszerű? A végeredmény pedig itt látható:

Ott van mind a 10 darab "Hello World!"

Jöhet következő áldozatunk, vagyis a do while ciklus. Ennek az a lényege, hogy míg a while nem biztos, hogy akár egyszer is lefut. Elvégre az "i"nek egyből adhattuk volna azt az értéket is, hogy 25, ami nagyobb, mint a 10...a ciklus így sosem futott volna le, ugyanis a futás előtt ellenőrzi a megadott feltételt. A do while, pont fordítva csinálja a dolgot. Lefut a ciklus, ellenőriz, ha megfelelt, akkor megint lefut és újra ellenőriz, egészen addig, amíg a feltétel teljesül. Ez annyit jelent, hogy ez a ciklus mindig lefut, legalább egyszer. Nézzük is meg, hogy hogyan néz ki:

#include<iostream>
using namespace std;
int main()
{
    string szoveg;
    szoveg="Hello World!";
    int i=0; //eddig minden ugyanúgy néz ki, mint az előbb
    do //innen jön a ciklus
    {
        cout<<szoveg<<endl; // a ciklusmag is teljesen megeggyezik
        i++;
    } while(i<10); //most pedig ellenőrzünk
    return 0;
}

Látható, hogy a feltétel a dolog működését is prezentálva, a ciklus végén helyezkedik el, elvégre akkor történik az ellenőrzése. Ezt nem fogom tovább ragozni, majdnem teljesen ugyanaz, mint a while ciklus. Igazából nem is túl gyakran használjuk, vagyis én nem használtam eddig valami gyakran. 

Most pedig jöhet a talán leggyakrabban használt ciklus, a számláló ciklus. Ez már egy kicsit kompaktabb móka. Viszont ezt is könnyű használni és igen hasznos. Lássuk hát!

#include<iostream>
using namespace std;
int main()
{
    string szoveg;
    szoveg="Hello World!"; //eddig minden stimmel
    for(int i=0;i<10;i++) //Teremtőm, itt meg milyen bonyolult feltétel van! Na jó, nem is, mindjárt megértjük!
    {
        cout<<szoveg<<endl; //ciklus mag megegyezik, viszont az "i++;" elköltözött
    }
    return 0;
}

Jöjjön a magyarázat! Lett egy nagyon szép feltételünk: (int i=0;i<10;i++) ez ugyanaz, mint ami eddig volt, csak egy kicsit tömörebben és egyszerűbben. Az első részben megadjuk, hogy amit vizsgálunk, az egy "i" nevű egész szám legyen, ami kezdetben nulla (int i=0), aztán megmondjuk, hogy meddig menjen a ciklus. Addig menjen amíg "i" barátunk kisebb, mint tíz (i<10). Ezután pedig jön a szokásos, növeljük az "i" értékét dolog (i++). Mindent szépen megcsináltunk, méghozzá egy lépésben. Ezért már semmi mással nem is kell foglalkoznunk, csak a ciklusmaggal. Ugye milyen kényelmes? 
Szerintem egyelőre bőven elég is ennyi a ciklusokról. Amennyiben valami nem érhető, kommentben nyugodtan tessék kérdezni! Egyébként a másik ciklusnál direkt nem fotóztam le a kimenetet, ugyanis teljesen ugyanaz, mint az első ciklusnál. Jó tanulást!

2012. február 7., kedd

Szünet

Hejhó, úgy gondoltam, hogy beugrom egy pillanatra, bár egyelőre csak azért, hogy életjelet adjak. Ennél a blognál úgy gondoltam, hogy folyamatosan fogom vezetni a tanulmányaimmal, csak az a baj, hogy ez a dolog az első félév vége felé jutott eszembe. Azóta már túl vagyok az első vizsgaidőszakomon is, ami eléggé vegyes szájízzel telt. A blogot természetesen folytatni fogom, bár kicsi érdekes lesz a felépítése és a tempója, tekintve, hogy fél évvel le vagyok maradva a vezetésével. Minden esetre ez most arra is nagyon jó nekem, hogy kicsit visszarázódjak a tanulós, programozós egyetemi életvitelembe. Nem is nagyon húznám tovább a szót, ugyanis már hajnali 2 körül jár az idő és én meg már eléggé hulla vagyok. Ami jönni fog...a C++ vonal menni fog továbbra is, ugyanis a suliban még mindig ezt fogjuk venni. Viszont igyekezni fogok nagyon gyorsan ledarálni itt az előző féléves anyagot, majd minden előadás/gyakorlat után megdobni titeket egy szép, zsíros bejegyzéssel. Így nagyjából azt fogjátok tudni, amit nekem leadnak az egyetemen. A második félévben már kicsit izgalmasabb lesz a  progtéma, jönnek a grafikus mókák, egyszerűbb játékokat is kell majd csinálni és mesterséges intelligenciát programozni. Biztos nagyon mókás lesz, amiből szerencsére ti sem fogtok kimaradni. Ami C++ mellett még várható lesz...csütörtökönként nem lesznek óráim, így úgy gondoltam, hogy minden csütörtökön előveszek majd valamit, ami nem törzsanyag a sulimban. Egyelőre valami webes prognyelven gondolkodom, igazából a PHP-be már bele is kezdtem, szóval arról tudnék írni. Ezen kívül érdekel még a java egyik aranyossága, ami a play framework névre hallgat. Ezeken kívül, ami jöhet még...fizika, méréstechnika. Igazából lesz menedzsmentem is, de arról nem hiszem, hogy fogok írni, annál már annak is örülni fogok, ha túlélem. Nagyjából ez lenne a terv, remélem sikerül tartanom magam hozzá. A következő bejegyzésben pedig jönnek a vezérlési szerkezetek, először a ciklusok, majd az elágazások. Legyetek jók és ne vegyetek példát rólam, vagyis tanuljatok!

2011. november 24., csütörtök

Tároljunk adatot, használjunk változót!

Nyilván szeretnék programunkban különböző műveleteket végezni adatokkal, ezt ugye úgy a legcélszerűbb, ha eltároljuk a szükséges adatokat. Erre használhatjuk a különböző változókat, melyek a memória egy-egy apró kis részei. Olyanok mint a fiókok, beléjük rakhatjuk a megfelelő típusú adatokat.
Megfelelő típus? Ilyesmiről ugye eddig nem volt szó. Ugye dolgozhatunk számokkal, szövegekkel és hasonló dolgokkal, ezeket hívjuk típusoknak. A következő típusok fordulnak elő a leggyakrabban:

int, vagyis integer, ezek az egész számok

double, ezek a valós számok, alias a tizedestörtek

char, ami a character rövidítése, jelentése karakter, egy ilyen változóba egy-egy betűt tudunk eltárolni

string, karakterfolyam, vagyis szöveg, ebben tudjuk elhelyezni a hosszabb szövegeket

bool, teljes nevén boolean. Ez egy logikai változó, mely elég aranyos. Kétféle értéket vehet fel, igaz/hamis, igen/nem,true/false,0/1 így szoktuk jellemezni. Mi maradjunk a true(igaz)/false(hamis) felállásnál.

Talán ezek a leglényegesebbek. Szóval egyelőre érjétek be ennyivel. Most pedig lássuk, hogy mit tudunk csinálni ezekkel a változókkal.
Létre tudjuk hozni őket, ez úgy történik, hogy megadjuk a változó típusát, majd nevét, aztán pedig jön egy ";" ez a jel megtalálható minden utasítás (vagyis a változó létrehozás után is) végén.
int egesz;  //most létrehoztunk egy egész típusú változót
Ennek tudunk értéket is adni, a következő módon:
egesz=10; //most az egesz nevű fiókunkba beleraktuk a 10es számot
A létrehozást (ezt itt igazából deklarálásnak hívják) és az értékadást, egyszerre is elvégezhetjük.
int egesz=10; //ez ugyanaz a két fenti parancs, csak egyben.
A double-t nem részletezem, mert ugyanígy működik, csak abba a fiókba valós számokat is tehetünk.
A következő a karakter:
char karakter='a'; //nagyjából ez is ugyanúgy működik, de itt az értéket (vagyis a betűt) sima idézőjelbe (' ') kell tenni. A szöveg ettől annyiban tér el, hogy ott dupla idézőjelet (" ") kell használni, vagyis:
string szoveg="Ide mar tobb szoveget be tudunk irni" //azért  nem használok a kódban ékezetet, mert a C++ kicsit nehezen eszi meg őket, ezen egyelőre tegyük túl magunkat, majd később foglalkozunk vele.
Már csak a logikai barátunk maradt, nézzük meg őt is!
bool igaz=true; //ez egy igaz logikai változó
bool hamis=false; //ez pedig egy hamis

Ez a bejegyzés most csak ennyiről akart szólni, de azért legyen itt még egy kis példa. Ez ugyanaz a program lesz, mint az első programunk volt, annyi különbséggel, hogy itt a szöveget nem egyből kiíratjuk, hanem előbb eltároljuk egy szöveg típusú változóban, majd magát a változót íratjuk ki.

#include <iostream>

using namespace std;

int main()

{
string szoveg=  "Hello World!"; //belerakjuk a szöveget a változóba
cout<<szoveg; //kiíratjuk a változó tartalmát

return 0;

}

2011. november 23., szerda

C++ bevezető

Meggondoltam magam és mégis írok gyorsan egy kis C++ gyorstalpalót. Ez most tényleg gyors lesz, csak röviden ismertetem a lényeget. Én C++ programíráshoz a CodeBlocks nevű IDE-t (Integrated Development Environment) használom, mely innen letölthető. Egyébként bármely szövegszerkesztő megfelel a célnak, de egy megfelelő IDE-vel egyszerűbb az írt program futtatása és a hibák megtalálása. Most pedig egy egyszerű példaprogram:

#include <iostream>

using namespace std;

int main()
{
  cout<<"Hello World!";

return 0;
}

Ez a már szinte hagyománnyá vált kezdő program a programozók körében. Semmi mást nem csinál, csak kiírja a konzolra a Hello World! szöveget.

Itt látható a végeredmény

Most pedig következzék a magyarázat a kódhoz. Most igyekszem részletesen írni, később ez lehet változni fog, de ezt még meglátjuk. Először is a "//" dupla perjel az egysoros megjegyzéseket jelenti, ezeket nem fogja lefordítani és végrehajtani a számítógép. Ezért a programkód mellé odaírtam így megjegyzésben a lényeget. Ha valami nem érthető, vagy ha a jobbak esetleg hibát találnak valahol, kérem szóljanak!

Az #include kulcsszó azt jelenti, hogy kérünk szépen magunknak egy könyvtárat. A könyvtárakban vannak a már a készítők által régen megírt elemek, amiket mi fel tudunk használni.
Az #include <iostream>  azt jelenti, hogy mi a programunkban használni szeretnénk az <iostream> nevű könyvtárat. Mit is csinál a programunk? Kiír egy szöveget a konzolra, az iostream pedig pont ehhez kell. A szóban az IO, az input/output-ra utal, melynek jelentése bemenet/kimenet.
A kód következő részében megadjuk, hogy mely névteret szeretnénk használni. Erről sokat nem tudok mondani, mert nekem sem tanítottak még róla semmit, de eddig nem is volt rá szükségem, ugyanis eddig minden, amire szükségem volt, az std névtérben volt. Szóval a "using namespace std;" azt jelenti, hogy az std névteret (namespace) szeretnénk használni (using). Ez nekünk bőven elég lesz egyelőre.
Ezután következik ténylegesen a programunk, melyet a main metódus foglal magában. A metódusokról majd később írok, egyelőre elég azt tudni, hogy a következő képen néznek ki: valami(){}. A valami a metódus nevére utal (jelen esetben main), ezután a sima zárójelben tudunk megadni bemeneti értékeket a metódusnak. Ez  most mivel üres, azt jelenti, hogy nem adunk át értéket a metódusnak. A sima zárójel után következik a kapcsos zárójel, ezek mindig a blokkokat jelölik, a blokkon belül találjuk majd az utasításokat. Mivel a programunkat a main metódus foglalja magába, így a programunk a main metódus blokkjában lévő kód.
Na, most már tényleg a lényeg jön, amit a programunk csinál.  cout<<"Hello World!"; ez azt jelenti, hogy "írd ki légyszíves a konzolra azt, hogy Hello World!" A parancs amit használunk a cout, ebben is benne van a fentebb említett out(put), ez jelenti azt, hogy kifelé megy a dolog, ezután jön kettő darab < jel, melynek az iránya is jelzi, hogy hova is megy, amit akarunk. A szöveg felől mutat a kimenet felé, vagyis tényleg kifelé küldjük a dolgot. Ezután már csak a kiírandó szöveg van aposztrófok között. Az aposztrófok jelzik, hogy egy szöveget (string-et) íratunk ki.
Ez volt a lényeg, ugyan a program végén még ott van a return 0; is, de ez megint csak a metódusos dologhoz tartozik, szóval később fogom kivesézni. Egyelőre elég annyi, hogy illik odaírni, hogy szépen lefusson a programunk. A programot a "}" jel zárja, amely a main metódus blokkjának záró zárójelpárja.


Összefoglaló a programkód kommentelésével:

#include <iostream> //kérjük szépen az <iostream> könyvtárat a bemenet és kimenet használatához

using namespace std; //az std névteret szeretnénk használni, mert abban van, ami nekünk kell

int main() //meghívjuk a main metódust, melynek nincs bemenő paramétere

{            //ezzel a zárójellel indul a main metódus blokkja, vagyis innen kezdődik a programunk

  cout<<"Hello World!";  //küld ki a konzolra, hogy Hello World!

return 0; //a main metódus dobjon vissza egy 0át, vagyis minden rendben

}           //a main metódus blokkját lezáró zárójelpár, vagyis itt van vége a programunknak
Legközelebb jönnek a vezérlési szerkezetek, elágazások, ciklusok!