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

A 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.

A 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.

A 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;

A 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.

A 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.