Radu MetaTrader a blogja | További ingyenes és hasznos eszközök MetaTraderhez | Kérdésed merült fel? Kérdezz!
MQL4 Könyv tartalomjegyzék | Stratégiák programozása MetaTrader platformra | Fogalomtár | Gyakran Ismételt Kérdések

MQL4 könyv   Az MQL4 alapjai  Műveletek és kifejezések


Műveletek és kifejezések


Azért,  hogy megértsük az MQL4-ben lévő műveleteknek és kifejezéseknek a fontosságát, különleges analógiákra nincs szükség. Gyakorlatilag ezek ugyanazok mint az egyszerű számtani műveletek és kifejezések. Mindenki megérti hogy az f = n + m rekordban,az f az n és az m a tagok vagy változók, az = és  a + műveleti jelek, míg n + m egy kifejezés.

A könyv előző részében bemutattuk a különböző adat típusokat. Itt meg fogjuk ismerni ezen adatok közti lehetséges kapcsolatokat (a négyzetmétert nem mindig adhatjuk hozzá az almákhoz). Természetes MQL4-ben is van néhány korlátozás és szabály, hogy hogyan használjuk a kifejezéseket és a műveleteket.

Az Operand (operandus), az  Operation (művelet) az Operation Symbol (műveleti jel)  és Expression (kifejezés) meghatározása


Az operandus egy állandó, egy változó, egy tömb elem  vagy egy olyan érték, amit egy függvény adott vissza. (a függvényekről később fogunk tanulni a Függvények fejezetben, és a tömbökről a Tömbök bekezdésben; a tanulás  jelenlegi szakaszában az  operandusok megértéséhez elegendő amit az állandókról és változókról ezelőtt tanultunk).  Más  szóval  az operandus egy művelet alaptagja.

Az Operation (művelet) egy akció, amit az operandusokkal végeznek.

Az Operation symbol (műveleti jel) egy előre meghatározott karakter vagy egy karakterekből álló csoport, az a parancs, hogy hajtsák végre a műveletet.

Az Expression (kifejezés) az operandusok és műveleti jelek összetartozó csoportja; ez egy programrekord, ami egy adattípus kiszámított értékét jellemzi.

A műveletek fajtái

Az MQL4-ben a következő fajta műveletek vannak:

  • számtani műveletek;

  • értékadó műveletek;

  • relációs műveletek;

  • Boolean, kétértékű (logikai) műveletek;

  • bitenkénti műveletek;

  • vessző műveletek;

  • függvényhívás.

Műveleteket operátorokban használnak (lásd:Operátorok).Használatuknak csak az operátorokban  van értelme egy programban. A műveleti jelek használatának lehetőségét meghatározzák az operátorok tulajdonságai (ha az operátorok tulajdonságai megengedik, hogy használj egy műveletet, akkor tudod használni azt; különben nem szabad használni ezt  a műveletet). Tilos  az operátorokon  kívül használni a műveleti jeleket.

Arithmetikai (számtani) műveletek 

A következő szimbólumok (műveleti jelek) tartoznak a számtani műveleti jelek közé:

Szinbólum Művelet Példa Analógia
+ Értékek összeadása x + 2
- Kivonás vagy előjelváltás x - 3, y = - y
* Sorzás 3 * x
/
Osztás x / 5
% Az osztás maradéka A perc = az idő % 60
++ A változó értékének növelése 1-el y++ y = y + 1
-- A változó értékének csökkentése 1-el y-- y = y - 1

Értékadó műveletek

A következő szimbólumok az értékadó műveletekhez tartozó szimbólumok:

Szinbólum
Művelet Példa Analógia
= Az y változó  x értékét kapja у = x
+= Az y változó növelése x-el у += x y = y + x
-= Az y változó csökkentése x-el y -= x y = y - x
*= Az y változó szorzása x-el y *= x y = y * x
/= Az y változó osztása x-el y /= x y = y / x
%= Az  y változó x-el történő osztásának a maradéka y %= x y = y % x

Relációs műveletek

A következő szimbólumok a relációs műveletekhez tartozó szimbólumok:

Szinbólum Művelet Példa
== Igaz, ha x egyenlő y x == y
!= Igaz, ha x nem egyenlő y x != y
< Igaz, ha x kevesebb mint y x < y
> Igaz, ha x nagyobb mint y x > y
<= Igaz, ha x egyenlő vagy kevesebb mint y x <= y
>= Igaz, ha x egyenlő vagy nagyobb mint y x >= y

Boolean (kétértékű) (logikai) műveletek

A következő szimbólumok a Boolean műveletek szimbólumai:

Szimbólum Művelet Példa Magyarázat
! NOT (NEM) (logikai tagadás) ! х Igaz(1), ha az operandus értéke Hamis(0) ; Hamis(0) ha az operandus értéke nem Hamis(0)
|| OR (VAGY) (logikai választás) x < 5 || x > 7 Igaz(1), ha bármelyik feltétel igaz
&& AND (ÉS) (logikai összeadás) x == 3 && y < 5 Igaz(1), ha minden feltétel igaz

Bitenkénti műveletek

Bitenkénti műveleteket csak egész számokkal hajthatunk végre. A következő műveletek a bitenkénti műveletekhez tartoznak:

A kettes számrendszerben ábrázolt számok értékének a komplemense. A kifejezés értéke  1 minden olyan helyen, ahol a változó értékei 0, és 0 minden olyan helyen, ahol a változó értéke 1.

b = ~n;

A kettes számrendszerben ábrázolt számok számjegyeinek elmozdítása  jobbra. Ez a jobbra léptetés logikusan azt is jelenti, hogy minden helyet, ami kiürült a bal oldalon nullák fognak kitölteni.

x = x >> y;

 A kettes számrendszerben ábrázolt számok számjegyeinek elmozdítása  balra. Minden helyet, ami kiürült a jobb oldalon nullák fognak kitölteni.

x = x << y;

A kettes számrendszerben ábrázolt x és y változókon végrehajtott bitenkénti  AND ( ÉS)  művelet. A kifejezés értéke  1 (Igaz) minden helyen, ahol sem x sem y nem nulla; és a kifejezés értéke 0 (Hamis) minden másik helyen

b = ((x & y) != 0);

A kettes számrendszerben ábrázolt x és y változókon végrehajtott bitenkénti OR (VAGY)  művelet. A kifejezés értéke  1 (Igaz) minden helyen, ahol x vagy y nem nulla; és a kifejezés értéke 0 (Hamis) minden másik helyen.

b = x | y;

A  kettes számrendszerben ábrázolt x és y változókon végrehajtott bitenkénti EXCLUSIVE OR (KIZÁRÓ VAGY)  művelet. A kifejezés értéke  1 (Igaz) minden helyen, ahol x és y különböző bináris értékű; és a kifejezés értéke 0 (Hamis) minden másik helyen.

b = x ^ y;

Comma (vessző művelet)

A vesszőkkel  elválasztott kifejezéseket  balról jobbra számolják ki. A bal oldali kifejezésben levő számítások eredménye  hatással van a  jobbra lévő kifejezésre. Az eredmény típusát  és értékét a jobb oldalon lévő  kifejezés fajtája és értéke adja.

for (i=0, j=99;  i<100;  i++, j--) Print(array[i][j]); // Ciklus (hurok) utasítás

Az átvitt paraméterlistát (lásd később) hoztuk fel példaként.

My_function (Alf, Bet, Gam, Del) // Függvényhívás a paraméterek megadásával

Az operátorokról  és függvényekről részletesebben az Operátorok és a Függvények szakaszokban és az Operátorok  fejezetben olvashatunk.

Függvényhívás

A függvényhívás részletes leírása a Függvényhívás bekezdésben.

Hasonló operandusokon végrehajtott műveletek

Ha egy általános iskolai tanulónak azt mondanák, hogy egy olyan példa megoldása közben amiben ceruzák száma szerepel, neki operandusokat, műveleteket és kifejezéseket kell használnia, a szegény iskolás gyerek biztosan lehetetlennek találná azt. Miközben megnézi az operációk szimbólumait, azt gondolhatja, hogy a kódolás egy rejtélyes és nagyon bonyolult eljárás, csak egy fajta elit számára hozzáférhető. Mindazonáltal a kódolás egyáltalán nem nehéz. Ennek bizonyítására álljon itt néhány példa.


1. feladat:  Johnnak van 2 ceruzája, Pete -nek van 3 ceruzája. Ezeknek a fiúknak hány ceruzája  van összesen?:)

Megoldás: Legyen John ceruzáinak a száma A változó és Pete ceruzáinak száma B változó, míg az eredményt C-vel fogjuk jelölni.

A válasz ez lesz: С = А + В

Az Adat típusok szakaszban  bemutattuk  a változó deklarációjának  módszereit. A ceruzák dolgok, azaz, ez valami, ami alapvetően részként létezhet, (például lehet fél ceruza). Így ceruzákat reálisként változóként fogjuk deklarálni, azaz a változó típusa double.

Tehát a megoldást például következőképpen tudjuk, kódolni:

 double A = 2.0; // John ceruzáinak száma
double B = 3.0; // Pete ceruzáinak száma
double C = A + B; // Az összeg

Ebben az esetben,  nyilvánvaló, hogy a "+" műveletet azonos típusú változókkal végeztük.

A alábbi kifejezés értékének a típusa:

 A + B

a változóknak az a típusa lesz, mint a kifejezés összetevőinek a típusa. Jelen esetben ez double típus lesz.

Hasonló választ fogunk kapni az értékek közti különbségre (arra, hogy mennyivel több ceruzája van teszi Pete -nek Johnnál?):

 double A = 2.0; // John ceruzáinak száma
double B = 3.0; // Pete ceruzáinak száma
double C = B - A; // Két valós szám közötti különbség

A többi számtani műveletet hasonló módon használjuk:

 double C = B * A; // Két valós szám szorzata
double C = B / A; // Két valós szám hányadosa

Szintén hasonló számításokat hajthatunk végre az egész számokkal is. ( int típus)


2. feladat: A tanulók az órán a táblához  mentek felelni. John 2-szer ment, Pete 3-szor. A fiúk hányszor mentek a táblához összesen?

Megoldás. Legyen John útjainak száma X változó, Pete útjainak száma Y változó, és az eredmény legyen Z.

Ebben a példában, nekünk int típusú változót kell használnunk az események  természetéből fakadóan (nem tudsz a táblához menni 0.5-ször vagy 1.5-ször; a táblánál a felelet lehet jó vagy rossz, de minket csak a feleletek száma érdekel).

Ennek a problémának a megoldását így írhatjuk, hogy:

 int X = 2; // John útjainak száma
int Y = 3; // Pete útjainak száma
int Z = X + Y; // Az összeg

A különbség számításának az esetében vagy a szorzási és osztási műveleteknél is hasonló egyszerű módon járunk el:

 int X = 2; // Egész
int Y = 3; // Egész
int Z = Y - X; // Két egész szám különbsége
int Z = Y * X; // Két egész szám szorzata
int Z = Y / X; // Két egész szám hányadosa

A helyzet a string típusú változóval egy kicsit más:

3.feladat: Egy a ház sarkánál van egy fűszerraktár, a neve "Arctic". Ugyanannak a háznak a másik sarkánál egy női fodrászat a neve "Hairdressing Saloon". Mit írnak a házra?

Megoldás. az MQL4-ben  megengedett, hogy összeadjuk  a string  típusú állandókat és változókat. Ha hozzá adunk egy string  típusú változót, egy másik string  típusú változóhoz, akkor egész egyszerűen egy sorban  jelennek meg a kifejezésben.

Könnyű kódolni egy olyan programot, ami megadja a szükséges választ:

 string W1 = "Arctic"; // 1.string 
string W2 = "Hairdressing Saloon"; // 2.String
string Ans = W1 + W2; // A stringek összege

Az Ans változó típusa string lesz ami következőképpen jelenik meg:

ArcticHairdressing Saloon

Nem történt semmi váratlan,  helyesen alakult  a string értéke. A gyakorlati kódolás során természetesen oda kell figyelni a szóközökre és egyéb központozásra.

Bármilyen más számtani művelet a string típusú változókkal tilos:

 string Ans= W1 - W2; // Tilos
string Ans= W1 * W2; // Tilos
string Ans= W1 / W2; // Tilos

Typecasting (A változó típusának módosítása)


A typecasting (típusmódosítás) egy operandus vagy egy kifejezés típusának módosítása (megfeleltetése) . A műveletek végrehajtása előtt módosítjuk az operandusok típusát (az értékadó műveletet kivéve), a legmagasabb prioritású  típusú operandus típusára, míg az  értékadó műveletek esetén, a  végrehajtás előtt a céltípushoz módosítjuk őket.


Nézzük hogyan lehet kezelni a problémákat a typecastinggel!

4. feladat:  Johnnak 2 ceruzája van, míg Pete 3-szor ment a táblához. Mennyi ez összesen?

Ami a formális gondolkodást illeti, a probléma nyilvánvalóan megoldhatatlan. Magától értetődik, hogy az eseményeket nem lehet összeadni a dolgokkal.

5. feladat: Egy a ház sarkánál van egy fűszerraktár, a neve "Arctic", míg Johnnak van 2 ceruzája.:)

Szintén reménytelen (a hétköznapi gondolkodás szerint) bármelyik kérdést feltenni:

1. Összesen mennyi?  vagy

2. Mi van írva a házra?

Ha helyesen akarod megoldani mindkét fenti problémát az MQL4 szabályai szerint, ismerd meg a typecasting szabályokat. Először is arról kell beszélgetnünk, hogy a különböző típusú változók hogyan képviseltetik magukat a számítógép memóriájában.

Azok az adattípusok, mint például az int, bool, color, datetime és double, a számszerű adattípusokhoz tartoznak. Az int, double, bool, color és a  datetime állandók belső ábrázolása egy szám. Az int, bool, color és a datetime változókat egész számok  képviselik a számítógép memóriájában, míg a double típusú változók lebegőpontos azaz valós számok. Az string tipusú állandók és változók karakterek. (16. ábra).

Az int, bool, color és a datetime  értékeit egész számok képviselik a számítógép-memóriában. A double típus értékeit valós számok képviselik a számítógép-memóriában. A string értékeit karakterek képviseli a számítógép-memóriában. Az int, bool, color, datetime és a double típusok értékei a számszerű értékek. A string  értékei a karaktertípusú értékek.



16. ábra. A számítógép-memóriában levő különböző adattípusok ábrázolása.

Megemlítettük fent, hogy az int, bool, color és a datetime változóknak az értékeit egész számok képviselik a számítógép-memóriában, míg a double típusúakat - valós számok. Tehát ha arra vagyunk kíváncsiak, hogy  egy olyan kifejezésnek  a típusa ami különböző típusú változókból áll milyen lesz, akkor csak három adattípus között tudunk választani: int, double és string. A bool, color és datetime értékei egy kifejezésben ugyanúgy viselkednek mint  az int típus értékei.

Tehát milyen típus lesz egy kifejezésnek az értéke, ami  különböző típusú operandusokból állt? MQL4-ben  a következő  typecasting  szabályok érvényesülnek:

  • ha a kifejezés különböző típusok operandusait tartalmazza, a kifejezés típusa a legmagasabb prioritású típus lesz; az int, bool, color a datetime egyenlő prioritásúak, míg a double típusnak magasabb prioritása van, és a string típus prioritása a legmagasabb;

  • ha az értékadó műveleti jelnek a  jobb oldalán levő kifejezés típusa nem esik egybe  a műveleti jel bal oldalán levő változó típusával, ennek a kifejezésnek a  típusát az értékadó műveleti jel bal oldalán levő változó típusa adja; ezt hívják a cél-típus módosításnak;

  • tilos  a string tipust bármilyen más típusra változtatni.

És most térjünk vissza a 4.feladathoz! Két megoldás is kínálkozik.

4.1 megoldás:  int típusú eredmény   számítása:

 double A = 2.0; // John ceruzáinak a száma
int Y = 3; // Pete útjainak a száma
int F = A + Y; // Az eredmény

Először is, nekünk tudnunk kell a kifejezés értékét, feltéve, hogy az operandusai különböző típusúak. A következő kifejezésben:

 A + Y,

két operandus adattípust használnak: А - double típus, Y – int típus.


A  typecastinggel kapcsolatban megismert szabállyal összhangban, ennek a kifejezésnek az értéke  double típusú szám lesz. Jegyezzük meg: Csak az A+Y kifejezés típusáról beszélünk, de nem az F változó tipusáról ami az értékadó műveleti jel bal oldalán szerepel. Ennek a kifejezésnek az értéke 5.0 valós szám. Azért hogy megállapítsuk  az A+Y kifejezés tipusára alkalmazzuk az előző  részben megismert  typecasting szabály.

Az A+Y kifejezés kiszámítása után az értékadó műveletet végrehajtják. Ebben az esetben, a tipus hibásan illeszkedik: az A+Y kifejezés típusa double, míg az F változó int. Az értékadó műveletet végrehajtása alatt: Először az  A+Y kifejezést int-ként alkalmazzák  (az egész számok számítási szabálya szerint) és egész számmá válik: 5; akkor ez az eredmény válik az F változó értékévé. A számításokat végrehajtásának a második része  a cél-típus módosítás szabály alkalmazása. A számítások és manipulációk végeredménye következő : Az  F változó típusa int értéke  5 egész szám.

4.2. megoldás: hasonló a helyzet, ha arra törekszünk, hogy a double típusú érték legyen egy eredményünk:

 double A = 2.0; // John ceruzáinak száma
int Y = 3; // Pete útjainak a száma
double F = A + Y; // Az eredmény

Ez a helyzet abban különbözik az előzőtől, hogy  a F célváltozó típusa (az értékadó operátor bal oldalán) double  ami egybeesik  az A+Y kifejezés típusával (double) tehát nekünk itt nincs semmilyen cél-típusmódosító feladatunk.  A számítások eredménye (az F változó értéke double) valós szám: 5.0.

Most keressünk egy megoldást, az 5. feladatban felmerült kérdésre a változók inicializálásánál:

 string W1 = "Arctic"; // 1. string 
double A = 2; // John ceruzáinak a száma

5.1 megoldás: A lehetséges megoldás erre a problémára:

 string W1 = "Arctic"; // i. string
double A = 2; // John ceruzáinak a száma
string Sum = W1 + A; // A jobb oldalon létrejövő transzformáció

Itt a jobb oldalon összeadjuk két változó értékei: egy string típusút, és egy double típusút. A typecasting szabály szerint az A változó értékét először  string típusra módosítjuk  (mivel ez a típus magasabb prioritású), azután az azonos típusú értékeket összeadjuk  (összefűzés). Az értékadó operátor jobb oldalán levő eredmény típusa string lesz. A következő lépésben ezt az értéket kapja Sum string változó. Végül Sum változó értéke a következő string lesz:

Arctic2.00000000

5.2. megoldás: Ez a megoldás hibás:

 string W1 = "Arctic"; // 1. string
double A = 2; // John ceruzáinak a száma
double Sum = W1 + A; // Ez nem elfogadható

Ebben az esetben, megszegjük a cél-típus módosítás egyik tilalmát, mivel a string típust módosítjuk. A W1+A, kifejezés típusa  az előző megoldásban string volt. Amikor az értékadó műveletet végrehajtjuk, a cél-típus módosítást is végre kell hajtani. Azonban a fentebbi szabály szerint a string típus módosítása alacsonyabb prioritású típusra tilos. Ez egy olyan hiba, amit észlelni fog MetaEditor a program létrehozásánál (a fordításánál).

Általában, a betartandó szabályok ezen része tiszta és egyszerű: Ha kiszámítasz bármilyen értéket, neked a legmagasabb prioritással rendelkező típust kell céltípusnak választanod. Typecasting alacsonyabb prioritásra csak számszerű értékekel megengedett, míg a stringek nem változhatnak át számokká.

Az egész számokkal végzett számítások

 

Az egész számok a tört rész nélkül számok. Ha összeadjuk vagy kivonjuk őket, szemléletes eredményt fogunk kapni. Például, ha:

 int X = 2; // Első int változó
int Y = 3; // Második int változó

és:

 int Z = X + Y; // Összeadás 

nem probléma kiszámítani a Z változó értékét: 2 + 3 = 5

Hasonlóan, ha egy szorzási műveletet hajtunk végre:

 int Z = X * Y; // Szorzási művelet,

az eredmény megjósolható: 2 * 3 = 6

De milyen eredményt kapunk, ha a programunknak végre kell hajtania egy osztást?

 int Z = X / Y; // Osztási művelet

Könnyű 2 / 3-ot írni. Azonban ez nem egy egész szám. Tehát mi lesz a X/Y kifejezés értéke és a Z változó?

Az egész szám (int) számítási szabálya abban áll, hogy a tört részt eldobjuk.

A fenti példában az egyenlőségjelnek a jobb oldalán levő kifejezés csak egész számokat tartalmaz, tehát ebben az esetben typecasting nem történik. És ez azt jelenti, hogy az X/Y kifejezés típusa int és a X/Y (=2/3) kifejezés egész értéke 0 (nulla). Ezt az értéket (nulla) fogja kapni a Z változó.

Természetesen, az X és Y változók más értékeire másfajta eredményt fogunk kapni. Például, ha:

 int X = 7; // Egy int változó értéke
int Y = 3; // Egy int változó értéke
int Z = X / Y; // Osztási művelet,

akkor 7/ 3  lesz az X/ Y kifejezés értéke és a Z változó 2 (kettő) lesz.

A műveletek rendje

 

A számítási szabály a következőben áll:

Egy kifejezés értékét a prioritások szerint  aritmetikai műveletekkel és balról jobbra kell kiszámolni, a typecasting szabályt mindegyik közbenső eredménynél be kell tartani.

Szemléltessük a számítás menetét a következő példával:

 Y = 2.0*( 3*X/Z - N) + D; // Példa kifejezés

Az egyenlőségjel jobb oldalán levő kifejezés két összetevőből  áll: 2.0*( 3*X/Z - n) és D. A  2.0*( 3*X/Z - n) pedig két tényezőből: 2.0 és (3*X/Z - n). A zárójelben lévő 3*X/Z - n két összetevőből áll, és végül a 3*X/Z összetevő három tényezőből áll mégpedig: 3, X és Z.

Azért hogy az egyenlőségjeltől jobbra lévő kifejezést kiszámítsuk, először ki fogjuk számolni a 3*X/Z kifejezést. Ez a kifejezés két műveletet tartalmaz (szorzás és osztás) ezek azonos rangúak, tehát ezt a kifejezést balról jobbra haladva számoljuk ki. Először ki fogjuk számítani a 3*X kifejezés értékét, az eredmény típusa ugyanaz lesz, mint az X változónak. Ezzel a típussal ki fogjuk számítani, a 3*X/Z kifejezés értékét és típusát, ami a typecasting szabály szerint kapunk. Azután a program ki fogja számítani a 3*X/Z- n kifejezés értéket és fajtáját, azután - a 2.0*(3*X/Z- n) kifejezést, és végül az egész 2.0*(3*X/Z- n) + D kifejezést.

Könnyű belátni, hogy egy programban levő műveletek rendje a matematikaihoz hasonló. Mindazonáltal a korábbi különböző közbenső számítások eredményének a típusa és értéke jelentős befolyást gyakorol a számítások végeredményére. Különösen (a matematikában elfogadott szabályoktól eltérően), egy kifejezésben levő műveletek sorrendje nagyon fontos. Hogy ezt demonstráljuk, fontoljunk meg egy kis példát.

6. feladat: számoljuk ki az А/В*С és А*С/В kifejezések értékeit, ha  А, В, és С egész számok.

A számítás eredményével kapcsolatban intuitív módon arra számítanánk, hogy mindkét esetben ugyanaz. Azonban ez a feltételezés csak valós számokra igaz. Ha int típusú operandusokból álló kifejezések értékeit akarjuk kiszámítani, mindig figyelembe  kell vennünk a közbenső eredményt. Ilyen esetben az operandusok sorrendje alapvető fontosságú:

 int A = 3; // Int tipusú érték
int B = 5; // Int tipusú érték
int C = 6; // Int tipusú érték
int Res_1 = A/B*C; // Eredmény 0 (nulla)
int Res_2 = A*C/B; // Eredmény 3 (három)

Előbb számítsuk ki az A/B*C: kifejezést

1. Először  (balról jobbra) az A/B  kifejezés értékét kiszámoljuk ki. A fenti szabályok szerint, a kifejezés (3/5) egész szám értéke 0 (nulla).

2. Kiszámolva a 0*С kifejezés (nulla szorozva С). Az eredmény 0 (nulla) egész szám.

3. Végeredmény (a Res_1 változó értéke) 0 (nulla) egész szám.

Most kövessük azt az utat,  hogy kiszámítjuk az A*C/B kifejezést!

1. A*C kiszámítása.  Ennek a kifejezésnek az értéke egész szám: 18 (3*6=18).

2. A 18/B kifejezés kiszámítása. A válasz nyilvánvaló: a tört részt eldobtuk, (18/5) eredménye 3 (három) egész szám.

3. Végeredmény (a Res_2 változó értéke) 3 (három) egész szám.

A fenti példa csak egy kis kódrészlet, amiben az int típusú változók értékeivel számoltunk. Ha lecseréljük ezeket a változókat ugyanolyan értékű állandókra, a végeredmény ugyanaz lesz. Miközben egész számokat tartalmazó kifejezéseket számítasz ki, figyelned kell a programsoraid tartalmára. Különben hiba történhet a kódodban, amit később felfedezni és javítani nagyon nehéz, (különösen nagy programokban). Ilyen hibák nem történnek valós számokkal végzett számításokban. Ha egy összetett kifejezésben a különböző típusok operandusait használod, a végeredmény egy olyan véletlenszerűen kialakított résztől függhet, ami egész számokat tartalmaz.

Az Operátorok bekezdésben az operátorok meghatározását és általános tulajdonságait tárgyaljuk, míg az egyes operátorok különleges tulajdonságait az Operátorok fejezetben írjuk le.