4. fejezet: Kiírások és alapvető típusok

Egy kicsit továbbgondoljuk a "Hello World!"-öt.

A program azonnal véget ér. Ez előtt nem ártana bekérni legalább a billentyűzetről egy gombot.

Erre van a "cin", azaz console input. (Ismétlésként: "cout" = kimenet. )

A forráskód legyen a következő:

 

---------------------------------------------

// 2. programom C++ nyelven

#include <iostream>

using namespace std;

int main ()

{

  cout << "Hello World!" <<endl;

  cin.get();

  return 0;

}

---------------------------------------------  

 

Itt már láthatjuk, hogy a "Hello World" után a program várakozik: egy tetszőleges karaktert kér, utána pedig egy ENTER-t.

 

Újdonságok:

A C++ nyelvben a szabványos I/O kimenetek kezelésére a cin és cout adatfolyamokat ( más néven STREAM-eket ) használjuk. (I/O = Input és/vagy Output azaz Be- és kimenet)

A C++ minden eddig használt elemet egy közös „std” névterületen definiál.

#include : Ezzel egy bizonyos függvények "alapjait" hívhatjuk le. Mely most az <iostream> lesz.

<iostream> :Ez az I/O függvények alapját "adja meg". Ezeket mindig < és > jelek közé kell tenni.

 

using namespace std : Ez az std névterület lehívása.

int main() : Az oldalon található ennek a függvénynek a leírása.

cout << : Kiírást lehetővé tevő adatfolyam, mely után mindig << jelet kell tenni, hisz ez is a függvényhez tartozik.

endl; : Sort emel, tehát ha a programunkban ez után a függvény után írunk valamit akkor az már a következő sorba fog kerülni. (end line)

cin.get(); : Ezzel a paranccsal tudunk várni egy billentyű leütésére a programunk végén.

 

Ki lehet próbálni ugyanezt a programot megírni enélkül a sor nélkül, ekkor azt fogjuk tapasztalni, hogy nem látjuk azt a bizonyos "DOS"-os szerű ablakot, mert a program egyszerre elindítás után be is záródik. A zárójelek azért kellenek, hogy ha valamilyen paramétert megadunk a függvénynek akkor azzal fogja végrehajtani magát.

 

Ha már ez ilyen jól megy, akkor próbáljuk meg azt is, hogy a beírt szöveget kiírassuk (újra)!

 

---------------------------------------------

// 3. programom C++ nyelven

#include <iostream>

using namespace std;

int main ()

{

    // változók deklarálása

    int valami;

 

    cout << "Kerem, irjal be valamit!" <<endl;

    cin >> valami;

    cout << "Koszonom!" <<endl;

    cout << "Ezt irtad be: " <<valami <<endl;

    return 0;   

}

---------------------------------------------

 

Újdonságok:

Minden változót még a használata előtt deklarálni kell. Erre szolgál: "int valami;" Ez mondjuk éppen egész számot deklarál. A többi már ismerős, legfeljebb az lehet a furcsa, hogy ékezet nélkül kell (egyenlőre) használni a nyelvet.

Ez csak annyiban lesz különös, hogy mindenképpen számokat kér, de a C++ nyelv nem nagyon válogatós, így a beírt szöveget átkonvertálja számmá, majd így írja ki. Érdemes kipróbálni, hogy nekem a „c nyelv” bevitelre szépen kiírja a válaszát: 4273286. Ugyanis a változót egészként deklaráltuk, így az csak egész számot képes megjeleníteni! Ha ezen változtatni akarunk, akkor érdemes a deklarációban az "int" szócskák kicserélni "string"-re. Így már szöveget is vissza tudunk íratni!

 

---------------------------------------------

// 3. programom C++ nyelven – string verzió

#include <iostream>

using namespace std;

int main ()

{

    // változók deklarálása

    string valami;

 

    cout << "Kerem, irjal be valamit!" <<endl;

    cin >> valami;

    cout << "Koszonom!" <<endl;

    cout << "Ezt irtad be: " <<valami <<endl;

    return 0;   

}

---------------------------------------------

 

Fontos rész következik! A C++ nyelv alapvető típusai:

Név

Típus

Hossz

Lehetséges értékek

bool (logikai)

logikai

1 byte

true/false (igaz/hamis)

char (karakter)

karakter

1 byte

Pl.: 'a', 'b', …, 'Z', ...

int (egész)

egész

4 byte

Pl.: 1, 2, 16, 314, ...

short int vagy short (rövid egész)

egész

2 byte

Pl.: 1, 2, 16, 314, ...

long int vagy long (hosszú egész)

egész

4 byte

Pl.: 1, 2, 16, 314, ...

float (valós)

valós

4 byte

Pl.: 3,14, …

double (duplapontos valós)

valós

8 byte

Pl.: 299793,0

long double (hosszú duplapontos valós)

valós

8 byte

Pl.: 299793,0

string

szöveg

változó

Pl.: szöveg

wchar_t

szabad karakter

2/4 byte

Pl.: s

Az egyes verziókban (nyelvjárásokban) a típusok eltérőek lehetnek!

 

További információk és pontos értékhatárok: http://cplusplus.com/doc/tutorial/variables/

 

A C++ nyelvnek van néhány lefoglalt szava, melyek a következők - persze, egyes nyelvjárásokban ez is változhat:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while.

 

Ezek mellett kerülni kell a következők alkalmazását is:

and, and_eq, bitand, bitor, compl, not, not_eq, or, or_eq, xor, xor_eq

 

Mivel a C++ egy alapvetően kis-nagybetű érzékeny programozási nyelv, ezért a Betu, bEtu, BETu, BETU és a betu változó 5 különböző értéket képvisel.

 

---------------------------------------------

// 4. programom C++ nyelven - értékadás

#include <iostream>

using namespace std;

int main ()

{

  int egesz;

  egesz = 5;       // Sima értékadás

  cout <<egesz <<endl;

  cin.get();

  return 0;

}

---------------------------------------------  

 

A fenti programban is látható, hogy ezen a nyelven igen egyszerű az értékadás. Nem kell vele sokat küzdeni! Ami viszont fontos: a változó mindig legyen deklarálva, tehát előre meg kell adni a változó nevét és típusát, csak utána lehet értéket adni neki. Többen is el szokták követni azt a hibát, hogy a cout sor közepébe az egész értékének kiírása után egyből pontosvesszőt tesznek. Ez hiba, mivel utána egy sor-vége jelet (endl) rakunk, de ezért nem szeretnénk újabb cout-sort kezdeni. A kétfajta kiírás mehet egy sorban (értsd: parancsban) is, de akkor nem szabad középre pontosvesszőt rakni!

Szerencsére a nyelv rugalmassága miatt lehetőség nyílik a két lépés egyesítésére is, azaz deklaráció közben is lehet értéket adni. A következő példában ez szerepel:

 

---------------------------------------------

// 4. programom verziója C++ nyelven – deklaráció értékadással

#include <iostream>

using namespace std;

int main ()

{

  int egesz = 5;   // Deklaráció és értékadás

  cout <<egesz <<endl;

  cin.get();

  return 0;

}

---------------------------------------------  

 

A legtöbb C++ nyelvjárásban léteznek a következő állandók: (zárójelben az angol nyelvű változat)

\n         új sor (new line)

\r          kocsi vissza (carriage return)

\t          tabulátor (tab)

\v         függőleges tabulátor (vertical tab)

\b         visszalépés (backspace)

\f          lapemelés (form feed - page feed)

\a         riadó-jel (alert beep)

\'          aposztróf (single quote ')

\"         idézőjel (double quote ")

\?         kérdőjel (question mark ?)

\\          vissza-jel (backslash \)

 

Ezekből legtöbbször a \n fog szerepelni, mivel ezzel az állandó sorzáró endl kiírást tudjuk helyettesíteni úgy, hogy ez már az idézőjelen belülre kerülhet. Kicsit érthetőbbé teszi ezt a következő példa:

 

---------------------------------------------

// 5. programom C++ nyelven – Kiírások

#include <iostream>

using namespace std;

int main ()

{

  cout << "1. sor kiirasa" <<endl;  // hagyományos módon

  cout << "2. sor kiirasa\n";      // tömörített verzióval

  cout << "\n\n\n\n";               // 4 üres sor után vége a program futásának

  cout << "Kilepes";

  cin.get();

  return 0;

}

---------------------------------------------  

 

A következő anyag a vessző-operátor, ami egy újabb tömörített értékadási lehetőség.

A következő egy igen egyszerű lépést is lehetővé teszi a C++:

a = (b=3, b+2);

Magyarázat: először b-nek adunk értéket (3), majd az a-nak lesz értéke b+2, azaz 5. Azért ne felejtkezzünk meg arról, hogy előtte mindkét változót deklarálni kell!

A következő programban minderre látható is egy példa:

 

---------------------------------------------  

// 6. programom C++ nyelven – Értékadás

#include <iostream>

using namespace std;

int main ()

{

  int a,b;

  a = (b=3, b+2);

  cout <<"Ertekek: a = ";

  cout <<a;

  cout <<"; b=";

  cout <<b;

  cout << "\nKilepes";

  cin.get();

  return 0;

}

---------------------------------------------  

 

Ilyenkor azt érdemes megfontolni, hogy nem lehetne-e mindezt tömörebben?

Nos, természetesen! A kezdő, C++ nyelvvel ismerkedő programozóknak a fenti módszer javasolt. A gyakorlottabbak próbálkozzanak meg ezt tömörítve leírni – itt elsősorban a kiírási sorokra gondolok.

 

A számok között igen egyszerű  a konverzió is:

Konverzióként a következő is megengedett:

int i;                            // i deklarálása egészként értékadás nélkül

float f = 3.14; // f deklarálása valósként értékadással

i = int (f);    // típuskonverzió (előzőleg deklarált valósról egészre)

 

Lássuk mindezt programkörnyezetben is!

 

---------------------------------------------

// 7. programom C++ nyelven – Számok konverziója

#include <iostream>

using namespace std;

int main ()

{

    int i;              // i deklarálása egészként értékadás nélkül

    float f = 3.14; // f deklarálása valósként értékadással

    i = int (f);    // típuskonverzió (előzőleg deklarált valósról egészre)

    cout <<"i = " <<i;

    cout <<"\nf = " <<f;

    cout << "\nKilepes";

    cin.get();

    return 0;

}

---------------------------------------------

 

Másik lehetőség: a = sizeof (char);  // ez a char nevű változó méretét adja meg.

Nézzünk erre is egyszerű példát!

 

---------------------------------------------

// 8. programom C++ nyelven – Konverziók

#include <iostream>

using namespace std;

int main ()

{

    char charlie;

    int a;

    a = sizeof (charlie);

    cout << "charlie = " <<charlie;

    cout <<"\na =" <<a;

    cout << "\nKilepes";

    cin.get();

    return 0;

}

---------------------------------------------

 

 

 

5. fejezet: Alapvető típusok műveletei és konverziója

Műveletek gyakorlására először is lássuk az alapvető egész típusú műveleteket: összeadás, kivonás, szorzás. Erre is írjunk egy egyszerű programot!

---------------------------------------------

// 9. programom - Alapvető műveletek változókkal

#include <iostream>

using namespace std;

int main ()

{

  // Deklarálás:

  int a, b, osszeg,kulonbseg, szorzat;

 

  // változók értékének bekérése:

  cout << "Kerem az A valtozo erteket (egesz)!" << endl;

  cin >> a;

  cout << "Kerem a B valtozo erteket (egesz)!" << endl;

  cin >> b;

 

  // Számítások:

  cout << "A 1-gyel novelve: " << a+1 <<endl;

  osszeg = a + b;

  cout << "A es B o:sszege: " <<osszeg <<endl;

  kulonbseg = a-b;

  cout << "A es B ku:lo:nbsege: " <<kulonbseg <<endl;

  szorzat = a*b;

  cout <<"Szorzatuk: " <<szorzat;

 

//  cin >> vege;

  // program futásának vége

  return 0;

}

---------------------------------------------

 

Látható, hogy a C++ nem különösebben allergiás az üres helyek meglétére, illetve a kiírásokra.

Amire érdemes vigyázni: minden sor végén legyen pontosvessző!

Jogosan vetődik fel a kérdés, hogy hol van a negyedik alapvető művelet, az osztás. Nos, nem véletlenül maradt ki, ugyanis ez már kivezet az egészek köréből.

 

A programot ki kell egészítenünk azzal, hogy alkalmassá váljon az osztásra!

Először is kell egy deklaráció:

  double hanyados;

Aztán jöhet az osztás kiíratása is:

  hanyados = a/b;

  cout <<"Hanyadosuk: " <<hanyados  <<endl;

 

Így már menni fog! Fordítás után próbáljuk ki!

---------------------------------------------

// 10. programom - Alapvető műveletek változókkal osztással kiegészítve

#include <iostream>

using namespace std;

int main ()

{

  // Deklarálás:

  int a, b, osszeg,kulonbseg, szorzat;

 

  // változók értékének bekérése:

  cout << "Kerem az A valtozo erteket (egesz)!" << endl;

  cin >> a;

  cout << "Kerem a B valtozo erteket (egesz)!" << endl;

  cin >> b;

 

  // Számítások:

  cout << "A 1-gyel novelve: " << a+1 <<endl;

  osszeg = a + b;

  cout << "A es B o:sszege: " <<osszeg <<endl;

  kulonbseg = a-b;

  cout << "A es B ku:lo:nbsege: " <<kulonbseg <<endl;

  szorzat = a*b;

  cout <<"Szorzatuk: " <<szorzat <<endl;

 

// Itt jön a kiegészítés:

  double hanyados;

  hanyados = a/b;

  cout <<"Hanyadosuk: " <<hanyados  <<endl;

 

//  cin >> vege;

  // program futásának vége

  return 0;

}

---------------------------------------------

 

Azért ez mégsem egészen igaz, mert sajnos csak az egészrészét iratja ki.

Tehát ha szeretnénk maradékot képezni, akkor az osztásjel helyett "%" kell.

Még egy apróság: több nyelv az értékadást csak a programkód (vagy blokk) legelején szereti,  illetve engedi. A C++ szerencsére nem allergiás erre (sem), így az eddigi programot simán lehet folytatni...

 

Az értékadást elég rugalmasan kezeli a nyelv. Például nézzük meg az alábbi forráskódot:

---------------------------------------------

// 11. programom - Alapvető műveletek változókkal: csökkentés és növelés

#include <iostream>

using namespace std;

int main ()

{

  // Deklarálás:

  int a;

  // változók értékének bekérése:

  cout << "Kerem az A valtozo erteket (egesz)!" << endl;

  cin >> a;

  cout << "Eggyel no:velju:k meg az " <<a;

  a++;

  cout << " erteket, igy ez lesz: " <<a <<endl;

  cout << "Majd az uj erteket cso:kkentsu:k 2-vel.";

  a = a - 2;

  cout <<" Ez lesz: " <<a <<endl;

  return 0;

}

---------------------------------------------

 

Mint látható, itt egy változó értékét kéri be a billentyűzetről, majd 1-gyel megnövelve kiírja azt.

Végül 2-vel csökkentve újra kiírja. Ez csak az egyik növelési-csökkentési módszer a sok lehetséges közül...

Szerencsénkre a nyelv végtelenül rugalmas. Próbáljuk meg például az előző forráskód deklarációjában az "int"-et kicserélni "double"-re. Így már egyszerű valós számokkal is megy minden...

Itt jön egy elég érdekes tulajdonság, a C++ néha érthetetlen, mivel egy műveletet igen sok módon lehet elvégezni.

C++ kifejezés

Egyenértékű kifejezés

alap += növekmény;

alap = alap + növekmény;

a -= 5;

a = a - 5;

a /= b;

a = a / b;

alap *= növekmény + 1;

alap = alap*(növekmény+1);

c++;

c = c + 1;

 

Egy fontos tény: értékadásokban és aritmetikai műveletekben a C++ az alaptípusok között elvégez minden értelmes átalakítást, így azokat egymással tetszés szerint keverhetjük! Nézzük például a következő forráskódot:

---------------------------------------------

// 12. programom - Alapvető műveletek változókkal

#include <iostream>

using namespace std;

void valami_fuggveny() // értéket vissza nem adó függvény

{

     double d = 2.222; // lebegőpontos szám kezdeti értékadása

     int i = 7; // egész kezdeti értékadása

     d = d+i; // összeg értékadása

     i = d*i; // szorzat értékadása

     cout << d <<endl;  //ez valós szám lesz

     cout <<i <<endl;   // ez pedig egész

}

 

int main ()

{

  // Deklarálás:

  double a;

 

  // változók értékének bekérése:

  cout << "Kerem az A valtozo erteket (egesz)!" << endl;

  cin >> a;

  cout << "Eggyel no:velju:k meg az " <<a;

  a++;

  cout << " erteket, igy ez lesz: " <<a <<endl;

  cout << "Majd az uj erteket cso:kkentsu:k 2-vel.";

  a = a - 2;

  cout <<" Ez lesz: " <<a <<endl;

  valami_fuggveny();

  return 0;

}

---------------------------------------------

Új elemként itt a main() elé kitett kódrészlet lép fel. Ennek meghívása a main() elemen belül történik egyszerűen a nevére való hivatkozással ami itt a valami_fuggveny().

Látható, hogy itt a deklarációval együtt történik az értékadás (double d = 2.222;). Kiíratásból mindjárt kettő is van. A "d" kiíratásakor valós szám lesz, mivel a "d" egy valós változó, míg az "i" kiíratásakor az eredmény egész lesz. Ez a C++ szerint simán megy, szerencsére erre nem allergiás! (Ugye, kedves Pascal-hoz szokottak, milyen könnyebbség is ez!)

Jó, azért van egy kis akadékoskodás: egyes fordítók megjegyzik, hogy volt váltás a két típus közül, de ezt csak megjegyzésként teszi meg, nem pedig hibaként!