Alapok II.oldal

A nyelvben minden dologról megkell mondanunk, hogy mi az és mire szeretnénk használni majd a programunkon belül, aza deklarálnunk kell az általunk használni kívánt neveket.
- Itt jön elő a kérdés:
Mi az a deklaráció? Megegyezik vajon a definícióval?
A válasz egyszerű a második kérdésre: NEM!
Amikor deklarálunk akkor csak a név tulajdonságait (pl. nevét) adjuk meg a fordítónak. Mikor valamit definiálunk (azaz a definíciót használjuk), akkor a memóriában úgymond helyet hozunk neki létre. Ez természetesen helyfoglalással jár. Nagyon fontos , hogy a típust mindig megkell említenünk a fordítónak definiálás közben. Az is fontos, hogy több deklaráció is lehet, míg definíció csak egy darab. Figyelnünk kell még arra is, hogy a definiált változónak értéket kell, hogy adjunk!

Jöjjön most a 4. nagy csoport:
a változók

- Változó: Olyan memóriaterület, mely ha szabad, akkor a programban módosíthatjuk.
Olyan változók melyeket használni fogunk egy jó darabig:
int : értékkészlete: -2147483648 - 2147483647
char : értékkészlete: -128 - 127
bool : két értéke lehet: igaz, hamis
float : mint már említettem, ez egy lebegőpontos típus, értékkészlete: 3.4E-38 - 3.8E+38
double : valós típust jelöli, értékkészlete: 3.4E-4932 - 3.4E+4932

// jelekkel kommenteket írhatunk magunknak a programunkba, de ezt a program lefutásakor nem fogja mutatni, csak a forráskódban fogjuk látni. Ez a jel a sor végéig fejti ki hatását.
/* komment */ így is megadhatjuk a kommentünket, ez addig fejti ki hatását ameddig le nem zárjuk a */ jellel

Változókra példa
#include <iostreaam>;
using namespace std; //névterület felszabadítása (minden programunkban szükséges)
int main() // az alap függvény minden programnak egyszer tartalmaznia kell
{
int szam;
/* programunk tartalmazni fog egy egész szám típusú változót, melynek
azonosítója szam lesz. */
double szamm;
/* programunk tartalmazni fog egy valós szám típusú változót is, melynek
azonosítója szamm lesz. */
cout << "Kerlek irj be egy egesz szamot!" ; cin >> szam;
/*cout = kiírunk a képernyőre
cin = beolvasunk valamit billentyűzetről */
/*ezekkel a következő cikkemben fogok bővebben foglalkozni*/
cout << " Kerlek irj be egy valós szamot!"; cin >> szamm
cout << szam << szamm;
/*kiíratjuk a bekért számokat*/
cin.get(); cin.get()
/*várunk a billentyű leütésra ( azért kell kettő mert mikor az adatot bevittük enterrel
akkor az egyik "elveszett"*/
return 0;
}

Ezt a példát pedig köszönöm SLD fórumtársamnak :

#include <iostream>
using namespace std;

int main() {
/* ui_egesz deklarálása, ám a gyakorlatban
már most le lett foglalva a szükséges memóriaterület,
ennek magyarázata a későbbiekre marad */
unsigned int ui_egesz;
// f_lebego definiálása:
float f_lebego = 3.1415;
// ui_egesz értékadás:
ui_egesz = 258;
// d_lebego definiálása:
// Figyelem! Tizedesvessző (,) helyett pont (.) alkalmazása szükséges.
double d_lebego = -0.988978;

// Adatok kiírása:
cout << "Változók értékeinek kiírása:" << endl;
cout << "ui_egesz értéke: " << ui_egesz << endl;
cout << "d_lebego értéke: " << d_lebego << endl;
cout << "f_lebego értéke: " << f_lebego << endl;

cout << "Befejezéshez nyomj egy Entert..." << endl;
cin.get();

return 0;
}

4.1. csoport:
Típuselőírások

- A double, int , char típuselőírásokhoz más szavakat ( azaz típusmódosítókat ) kombinálva új típuselőírásokat hozhatunk létre.

- Típusmódosítók két fajta dolgot tehetnek:
1. Jelzik a típuselőíró méretét
2. Előjelessé vagy éppen előjel nélkülivé változtatják a típuselőírót

- Típusmódosítók melyek jelzik a típuselőíró méretét:
- short
- long
- long long

- Melyek az előjelet jelzik:
- signed
- unsigned

4.2 csoport:
Típusminősítők

- 2 típusminősítő van:
- const
- volatile
- A consttal létrehozott típuselőíró értéke nem változtatható meg, csak akkor mikor létrehozzuk.
- A volatile értéket pl. egy másik program megváltoztathatja.

Köszönöm szépen mindazoknak akik elolvasták a cikkemet, remélem, hogy ha csak egy kicsit is de tanulságos volt.

Köszönet: Karma fórum társunknak, aki megnézte az előző cikkemet!

Valamint ajánlom még Divrapier C# programozás cikkjét.