C++ Változók és típusok: Int, Char, Float, Double, String & Bool

C++ Változó adattípusok

C++ primitív típusok egész halmazát határozza meg

Az semmisnek típushoz nincsenek társított értékek, és csak néhány esetben használható. Leggyakrabban olyan függvények visszatérési típusa, amelyek nem adnak vissza értéket.

Az aritmetikai típusok karaktereket, egész számokat, logikai értékeket és lebegőpontos számokat tartalmaznak. Aritmetikai típus, ha tovább osztjuk 2 kategóriába

1. Lebegőpontos típusok. A float (vagy lebegő típus) decimális számokat jelent. Az IEEE szabvány meghatározza a jelentős számjegyek minimális számát. A legtöbb fordító általában a megadott minimumnál nagyobb pontosságot biztosít. A floatokat általában 32 bites, a duplázókat 64 bites, a hosszú duplákat pedig 96 vagy 128 bites ábrázolják.
2. Integrált típusok (amelyek karaktereket, egész számokat és logikai típusokat tartalmaznak). A logikai típusnak csak kétféle értéke van: igaz vagy hamis. Több is van faszén típusok, amelyek többsége a nemzetköziesedés támogatására létezik. A legalapvetőbb karaktertípus a char. A char akkora, mint egy gépi bájt, ami egyetlen bájtot jelent.

Az Integrált típusok lehet aláírt vagy aláírás nélküli.

Aláírt típus: Negatív vagy pozitív számokat jelentenek (beleértve a nullát is). Előjeles típusban a tartományt egyenletesen kell felosztani +ve és -ve értékek között. Így egy 8 bites előjeles karakter –127 és 127 közötti értékeket tartalmaz.

Aláíratlan típus: Előjel nélküli típusban minden érték >= 0. Egy 8 bites előjel nélküli karakter 0-tól 255-ig terjedhet (mindkettőt beleértve).

Változó neve vagy azonosítói

Az azonosítók állhatnak néhány betűből, számjegyből és az aláhúzás karakterből vagy ezek kombinációjából. A név hossza nincs korlátozva.

Azonosítókat kell

• betűvel vagy aláhúzással ('_') kezdődik.
• És megkülönböztetik a kis- és nagybetűket; a kis- és nagybetűk különböznek egymástól:

// négy különböző int változót határoz meg

int guru99, gurU99, GuRu99, GURU99;

Az C++ a nyelv fenntartott néhány nevet a használatához.

Számos elfogadott konvenció létezik a változók elnevezésére különböző programozási nyelvek. Ezen konvenciók betartása javíthatja a program olvashatóságát.

• Az azonosítónak legalább valamennyire utalnia kell a jelentésére.
• A változónevek általában kisbetűk – guru99, nem Guru99 vagy GURU99.
• Az általunk meghatározott osztályok általában nagybetűvel kezdődnek.
• A több szót tartalmazó azonosítóknak vizuálisan meg kell különböztetniük minden szót. Például guru99_website nem guru99website.

C++ Változó deklaráció és definíció

Egy változó deklarációja a program számára ismertté tesz egy nevet abban a körben, amelyben definiálva van. Példa:

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Const selejtező be C++

Tegyük fel, hogy van egy változó buffsize, amely megadja a felhasználótól átveendő bemenetek számát. Itt nem akarjuk megváltoztatni a buffsize értékét az egész programban. Olyan változót szeretnénk definiálni, amelynek értékét tudjuk, hogy nem szabad változnia.

Ilyen esetben használja a const kulcsszót

const int bufSize = 512;    // input buffer size

Ez a bufSize-t állandóként határozza meg. A bufSize hozzárendelésére vagy módosítására irányuló minden kísérlet hibát eredményez.

Itt nem tudjuk megváltoztatni a const objektum értékét a létrehozás után, kötelezően deklarálni és inicializálni kell. Ellenkező esetben a fordító hibát jelez.

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

A változók hatóköre C++

A hatókör egy program tartománya, ahol egy változónak van jelentése. Leggyakrabban ugyanaz a név használható különböző entitásokra a különböző hatókörön belül. A változók attól a ponttól láthatók, ahol deklarálják őket, egészen annak a hatókörnek a végéig, amelyben deklarációjuk megjelenik.

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

Ez a program 3 nevet határoz meg: fő, összeg és érték. Az std névtérnevet használja a névtérből származó két másik névvel együtt – a cout és az endl.

• A „main” függvény neve a kapcsos zárójeleken kívül van meghatározva. A fő függvénynév – mint a legtöbb más, a függvényen kívül definiált név – globális hatókörrel rendelkezik. Ami azt jelenti, hogy miután kijelentették, a nevek, amelyek a globális hatókör a program egész ideje alatt elérhetők.
• A változó összeget a fő függvény törzsét képező blokkon belül definiáljuk. Elérhető a deklarációs helyéről és a fő funkció törzsének többi részéből. Rajta kívül azonban nem. Ez azt jelenti, hogy változó összeg van blokk hatóköre.
• A val változó a „for utasítás” hatókörében van definiálva. Könnyen használható ebben az utasításban, de nem máshol a fő függvényben. Megvan helyi hatályú.

Beágyazott hatókör

A hatókör más hatóköröket is tartalmazhat. A foglalt (vagy beágyazott) hatókört belső hatókörnek nevezzük. A tartalmazó hatókör a külső hatókör.

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

1. kimenet az újrafelhasználás helyi meghatározása előtt jelenik meg. Így ez a kimenet

Az utasítás az, amely a globális hatókörben meghatározott újrafelhasznált nevet használja. Ez az állítás kimenet

42 0

2. kimenet az újrafelhasználás helyi meghatározása után következik be. Most a hatálya alá tartozik. Ezért ez a második kimeneti utasítás egyszerűen az újrafelhasznált helyi objektumot használja a globális helyett, és a kimeneteket adja

0 0

3. kimenet segítségével felülbírálja az alapértelmezett hatóköri szabályokat hatókör operátor. A globális hatókörnek nincs neve. Így amikor a hatókör operátor(::) bal oldala üres. A globális hatókör jobb oldalán található név lekérésére irányuló kérésként értelmezi. Így a kifejezés a globális újrafelhasznált és kimeneteket használja

42 0

Változó típusú átalakítás

Az egyik típusú változó egy másikra konvertálható. „Típuskonverzió” néven ismert. Lássuk a különböző konvertálási szabályokat C++ változó típusok:

Nem bool hozzárendelése bool változóhoz hamis értéket ad, ha az érték 0, egyébként igaz.

bool b = 42;            // b is true

Egy bool hozzárendelése egy másik aritmetikai típushoz 1-et ad, ha a bool igaz, és 0-t, ha a logika hamis.

bool b = true;
int i = b;              // i has value 1

Ha egy int típusú változóhoz lebegőpontos értéket rendelünk, akkor az értéke csonkolva lesz. A tárolt érték a tizedesvessző előtti rész.

int i = 3.14;               // i has value 3

Egy int érték hozzárendelése egy float típusú változóhoz azt eredményezi, hogy a tört rész nullává válik. A pontosság általában elveszik, ha az egész szám több bitet tartalmaz, mint amennyit a lebegő változó képes befogadni.

Int i=3;
double pi = i;          // pi has value 3.0

Ha megpróbálunk tartományon kívüli értéket rendelni egy előjel nélküli változóhoz, akkor az eredmény a %(modulo) érték maradéka.

Például egy 8 bites előjel nélküli karaktertípus 0 és 255 közötti értékeket tartalmazhat. Ezen a tartományon kívüli érték hozzárendelése azt eredményezi, hogy a fordító az érték maradékát modulo 256-hoz rendeli. Ezért a fenti logika szerint a –1 hozzárendelése egy 8 bites előjel nélküli karakterhez 255 értéket ad az objektumnak.

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

Ha megpróbálunk tartományon kívüli értéket rendelni egy aláírt típusú objektumhoz, az eredmény megjósolhatatlan. Ez meghatározatlan. Úgy tűnhet, hogy a program kívülről működik, vagy összeomolhat, vagy szemét értékeket produkál.

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

A fordító ugyanezt a típusú konverziót alkalmazza, amikor egy típusú értéket használunk, ahol más típusú értéket várunk.

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

Ha ez az érték = 0, akkor a feltétel hamis; minden más (nem nulla) érték igaz. Ugyanezen elv szerint, ha bool-ot használunk egy aritmetikai kifejezésben, annak értéke mindig 0-ra vagy 1-re lesz konvertálva. Ennek eredményeként a bool használata egy aritmetikai kifejezésben általában szinte biztosan helytelen.

Figyelem: Ne keverje az aláírt és az aláíratlan típusokat

Az előjeles és előjel nélküli kifejezések meglepő és téves eredményeket eredményezhetnek, ha az előjeles érték negatív. A fentebb leírtak szerint az előjeles értékek automatikusan előjel nélküliekké alakulnak.

Például egy számtani kifejezésben, mint pl

x* y

Ha x -1 és y értéke 1, és ha x és y is int, akkor az érték a várakozásoknak megfelelően -1.

Ha x int és y előjel nélküli, akkor ennek a kifejezésnek az értéke attól függ, hogy egy egész szám hány bitje van a fordítógépen. A mi gépünkön ez a kifejezés 4294967295-öt eredményez.

Változók regisztrálása

A regiszterváltozók gyorsabban érhetők el, mint a memóriaváltozók. Tehát olyan változók, amelyeket gyakran használnak a C++ segítségével a program regiszterekbe helyezhető Regisztráció kulcsszó. A regiszter kulcsszó azt mondja a fordítónak, hogy az adott változót egy regiszterben tárolja. A fordító döntése, hogy beírja-e a regiszterbe vagy sem. Általában maguk a fordítók végeznek különféle optimalizálásokat, amelyek magukban foglalják a változók regiszterbe vételét. A regiszterváltozók száma nincs korlátozva a C++ program. De a fordító nem tárolja a változót egy regiszterben. Ennek az az oka, hogy a regisztermemória nagyon korlátozott, és általában az operációs rendszer használja.

Meghatározni:

register int i;

Hozzászólások

A megjegyzések a kód azon részei, amelyeket a fordító figyelmen kívül hagy. Lehetővé teszi a programozó számára, hogy feljegyzéseket készítsen a forráskód/program megfelelő területein. A megjegyzések blokk formában vagy egysoros formában érkeznek. A program megjegyzései magyarázó nyilatkozatok. Belekerülhet a C++ kódot, amely segít bárkinek elolvasni a forráskódját. Minden programozási nyelv lehetővé teszi valamilyen megjegyzést. C++ támogatja az egysoros és többsoros megjegyzéseket is.

• Egysoros megjegyzések azok, amelyek // karakterrel kezdődnek és a sor végéig folytatódnak. Ha a megjegyzéssorban az utolsó karakter egy \, akkor a megjegyzés a következő sorban folytatódik.
• Többsoros megjegyzések azok, amelyek /*-al kezdődnek és */-re végződnek.

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

Menekülési szekvenciák

Egyes karaktereknek, például a backspace-nek és a vezérlőkaraktereknek nincs látható képe. Az ilyen karaktereket nem nyomtatható karaktereknek nevezzük. Más karakterek (egy- és dupla idézőjelek, kérdőjelek és fordított perjel) különleges jelentéssel bírnak a sok programozási nyelvben.

Programjaink nem tudják közvetlenül ezeket a karaktereket használni. Ehelyett egy escape szekvenciát használhatunk az ilyen karakterek ábrázolására. A escape szekvencia fordított perjellel kezdődik.

Az C++ programozási nyelv több menekülési szekvenciát határoz meg:

Mit tegyek?	Karakter
Új sor	\n
Függőleges fül	\v
backslash	\\
Szállítás vissza	\r
Vízszintes fül	\t
Backspace	\b
Kérdőjel	\?
Formfeed	\f
Figyelmeztetés (csengő)	\a
Double idézet	\ ”
Egyetlen idézet	\ '

Escape sorozatot használunk, mintha egyetlen karakter lenne:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

Írhatunk általánosított escape szekvenciákat is \x, amelyeket egy vagy több hexadecimális számjegy követ. Vagy használunk egy \-t, amelyet egy, két vagy három oktális számjegy követ. Az általánosított escape szekvencia a karakter numerikus értékét jelenti. Néhány példa (a Latin-1 karakterkészletet feltételezve):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

Használhatunk előre meghatározott escape szekvenciákat, mint bármely más karaktert.

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

Összegzésként

• A C++ változó egy elnevezett tárolási képességet biztosít számunkra.
• C++ változó típusok: int, double, faszén, float, string, bool stb.
• A beágyazott (vagy beágyazott) hatókört belső hatókörnek nevezzük, a tartalmazó hatókört pedig a külső hatókörnek.
• Az egyik típusú változó egy másikra konvertálható. „Típuskonverzióként” ismert.
• A regiszterváltozók gyorsabban érhetők el, mint a memóriaváltozók.
• A megjegyzések a kód azon részei, amelyeket a fordító figyelmen kívül hagy.
• Egyes karaktereknek, például a backspace-nek és a vezérlőkaraktereknek nincs látható képe.