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!