C ++ Változók és típusok: int, double, char, string, bool

Tartalomjegyzék:

Anonim

Változók C ++ -ban

A C ++ változó megnevezett tárolási lehetőséget biztosít számunkra. Lehetővé teszi a programozó számára, hogy az igényeknek megfelelően manipulálja az adatokat. Minden változó típusa C ++. A változó típusa segít meghatározni a változó memóriatérképének méretét és elrendezését, az abban a memóriában tárolható értéktartományt és a rá alkalmazható műveletek halmazát.

Ebben a C ++ oktatóanyagban megtudhatja:

  • Változók C ++ -ban
  • A változók alapvető típusai C ++ nyelven
  • A változók C ++ nyelven történő deklarálásának szabályai
  • C ++ változó adattípusok
  • Változó neve vagy azonosítói
  • Const Qualifier C ++ nyelven
  • A változók köre C ++ - ban
  • Változó típusú konverzió
  • Változók regisztrálása
  • Menekülési szekvenciák

A változók alapvető típusai C ++ nyelven

Itt vannak a C ++ változók alapvető típusai:

Int:

Az egész szám egy numerikus literál (számokkal társítva), töredék vagy exponenciális rész nélkül. Példa. 120, -90 stb.

Kettős:

Ez kettős pontosságú lebegőpontos érték. Példa: 11.22, 2.345

Char:

A karakter literál úgy jön létre, hogy egyetlen karaktert idézőjelek közé tesz. Például: 'a', 'm', 'F', 'P', '}' stb.

Úszó:

A lebegőpontos literál olyan numerikus literál, amelynek vagy tört, vagy kitevő alakja van. Például: 1.3, 2.6

Vonós literálok:

A karakterlánc egy karaktersorozat kettős idézőjelbe foglalva. Például: "Hogy vagy?"

Bool:

A logikai értéket igaznak vagy hamisnak tartja.

A változók C ++ nyelven történő deklarálásának szabályai

Íme néhány általános szabály a változó elnevezéséhez:

  • A C ++ változó neve csak ábécét, számot és aláhúzást tartalmazhat.
  • A C ++ változó neve nem kezdődhet számmal.
  • A változó nevek nem kezdődhetnek nagybetűvel.
  • A C ++ nyelven használt változó neve nem lehet kulcsszó. Például az int olyan kulcsszó, amelyet egész számok jelölésére használunk.
  • A C ++ változó neve aláhúzással kezdődhet. Ez azonban nem számít jó gyakorlatnak.

C ++ változó adattípusok

A C ++ egy egész primitív halmazt határoz meg

A void típushoz nincsenek társítva értékek, és csak néhány esetben használható. Leggyakrabban olyan függvények visszatérési típusaként, amelyek nem adnak vissza értéket.

A számtani típusok karaktereket, egész számokat, logikai értékeket és lebegőpontos számokat tartalmaznak. Számtani típus, ha további 2 kategóriára oszlik

  1. Lebegőpontos típusok . Az úszó (vagy lebegő típus) tizedes számokat képvisel. Az IEEE szabvány meghatározza a számjegyek minimális számát. A legtöbb fordító általában nagyobb pontosságot nyújt, mint a megadott minimum. Az úszókat általában 32 bites, a dupla 64 bites, a hosszú dupla pedig 96 vagy 128 bites ábrázolja.
  2. Integrált típusok (amelyek tartalmazzák a karaktert, az egész számot és a logikai típust). A logikai típusnak csak kétféle értéke van: Igaz vagy Hamis. Számos char típus létezik, amelyek többsége a nemzetközivé válás támogatására létezik. A legalapvetőbb karaktertípus a char. A karakter akkora, mint egy gép bájt, ami egyetlen bájtot jelent.

Az Integral típusok lehetnek aláírva vagy aláíratlanul.

Aláírt típus : Negatív vagy pozitív számokat képviselnek (beleértve a nullát is). Aláírt típus esetén a tartományt egyenletesen kell elosztani a + 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 az összes érték> = 0. Egy 8 bites előjel nélküli karakter 0 és 255 között lehet (mindkettőt beleértve).

Változó neve vagy azonosítói

Az azonosítók állhatnak egyes betűkből, számjegyekből és az aláhúzás karakteréből, vagy ezek kombinációjából. A név hosszára nincs korlátozás.

Az azonosítóknak meg kell adniuk

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

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

int guru99, gurU99, GuRu99, GURU99;

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

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

  • Az azonosítónak legalább némi jelzést kell adnia a jelentéséről.
  • A változó nevek általában kisbetűsek-guru99, nem pedig 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 az egyes szavakat. Például a guru99_website nem a guru99website.

C ++ változó nyilatkozat és meghatározás

Egy változó deklarációja a program számára ismertté teszi a nevet abban a körben, amelyben meghatározták. Példa:

int a=5;int b;char c='A';
int a,b;a=b=1000;
List initializationint a(5);int b{5};

Const Qualifier C ++ nyelven

Tegyük fel, hogy van egy változó buffsize, amely meghatározza a felhasználótól elvihető bemenetek számát. Itt nem akarjuk megváltoztatni a buffsize értékét a program során. Meg akarunk határozni egy olyan változót, amelynek értéke tudjuk, hogy nem változik.

Ilyen esetben használja a const kulcsszót

const int bufSize = 512; // input buffer size

Ez a bufSize-t konstansként definiálja. A bufSize hozzárendelésére vagy megváltoztatására tett bármilyen kísérlet hibát okoz.

Itt nem tudjuk megváltoztatni egy const objektum értékét, miután létrehoztuk, kötelezővé kell tenni, hogy deklaráljuk és inicializáljuk. Ellenkező esetben a fordító hibát dob.

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

A változók köre C ++ - ban

A hatókör egy olyan programtartomány, ahol a változónak jelentése van. Többnyire ugyanaz a név használható a különböző hatókörön belüli különböző entitásokra. A változók a deklarálásuk kezdetétől a deklaráció megjelenési körének végéig láthatók.

#include int main(){int sum = 0;// sum values from 1 through 10 inclusivefor (int val = 1; val <= 10; ++val)sum += val; // equivalent to sum = sum + valcout << "Sum of 1 to 10 inclusive is "<< sum <

Ez a program 3 nevet határoz meg, nevezetesen: fő, összeg és val. Az std névtér nevet használja, a névtér-cout és endl két másik névvel együtt.


    

  • A "main" függvénynév a göndör zárójeleken kívül van megadva. A main függvénynévhez hasonlóan 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 deklarálták, a globális hatókörű nevek az egész programban elérhetők.
    • 

  • A változó összeget a blokk hatókörében határozzuk meg, amely a fő funkció törzse. A bejelentési ponttól és a fő funkció teljes testén keresztül elérhető. Azonban nem azon kívül. Ez azt jelenti, hogy a változó összeg blokk hatóköre .
    • 

  • A val változót a "for utasítás" hatókörében definiáljuk. Könnyen használható ebben az utasításban, de máshol nem a fő funkcióban. Ez a helyi körét .
    • 



Beágyazott hatókör


A hatókör egyéb hatóköröket is tartalmazhat. A tartalmazott (vagy beágyazott) hatókört belső hatókörnek nevezzük. A tartalmazó hatókör a külső hatókör.


#include 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 nameint reused = 42; // reused has global scopeint main(){int unique = 0; // unique has block scope// output #1: uses global reused; prints 42 0cout << reused << " " << unique << endl;int reused = 0; // new, local object named reused hides global reused// output #2: uses local reused; prints 0 0cout << reused << " " << unique << endl;// output #3: explicitly requests the global reused; prints 42 0cout << ::reused << " " << unique << endl;return 0;}


Az 1. kimenet az újrafelhasználás helyi definíciója előtt jelenik meg. Így ez a kimenet


utasítás az, amely az újrafelhasználott nevet használja, amely globális terjedelemben van meghatározva. Ez az állítás eredményezi


42 0


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


0 0


A 3. kimenet felülírja az alapértelmezett hatókörszabályokat a hatókör operátor használatával. A globális hatókörnek nincs neve. Így amikor a hatókör operátor (: :) üres bal oldala van. Kérésként értelmezi a név beolvasását a globális hatókör jobb oldalán. Így a kifejezés a globális újrafelhasználást és az outputokat használja


42 0



Változó típusú konverzió


Egy típusú változó átalakítható másikká. "Típusátalakítás" néven ismert. Nézzük meg a különböző C ++ változótípusok konvertálásának szabályait:


Ha nem bool értéket rendel hozzá bool változóhoz, akkor hamis értéket kapunk, ha az érték 0, és másként igaz.


bool b = 42; // b is true


A bool hozzárendeléséhez a többi számtani típushoz 1-et kap, ha a bool igaz, és 0, ha a bool hamis.


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


Lebegőpontos érték hozzárendelése int típusú változóhoz megkapja a csonka értéket. A tárolt érték a tizedesjegy előtti rész.


int i = 3.14; // i has value 3


Az int érték hozzárendelése egy úszó típusú változóhoz azt eredményezi, hogy a tört rész nulla lesz. A pontosság általában elvész, ha az egész számnak több bitje van, mint amennyit a lebegő változó be tud fogadni.


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


Ha megpróbálunk tartományon kívüli értéket rendelni egy aláíratlan típusú változóhoz, az eredmény a% (modulo) érték fennmaradó része


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


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 kiszámíthatatlan. Nincs meghatározva. Úgy tűnik, hogy a program kívülről működik, összeomlik, vagy szemétértékeket produkál.


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


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


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


Ha ez az érték = 0, akkor a feltétel hamis; az összes többi (nem nulla) érték igaz. Ugyanezen koncepció szerint, amikor egy boolot számtani kifejezésben használunk, annak értéke mindig 0-ra vagy 1-re konvertálódik. Ennek eredményeként a bool számtani kifejezésben való használata általában szinte biztosan helytelen.


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


Az aláírással és az aláírással kevert kifejezések meglepő és rossz eredményeket hozhatnak, ha az aláírt érték negatív. Amint a fentiekben tárgyaltuk, az aláírt értékeket automatikusan konvertáljuk előjel nélkülivé.


Például olyan számtani kifejezéssel, mint


x* y


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


Ha x int és y nincs aláírva, akkor ennek a kifejezésnek az értéke attól függ, hogy egy egész szám hány bit van a fordító gépen. Gépünkön ez a kifejezés 4294967295-et eredményez.



Változók regisztrálása


A regiszter változókhoz a memóriaváltozókhoz képest gyorsabban lehet hozzáférni. Tehát a C ++ programban gyakran használt változókat regisztrációs kulcsszóval be lehet helyezni a regiszterekbe . A regiszter kulcsszó arra utasítja a fordítót, hogy tárolja az adott változót egy regiszterben. A fordító döntése, hogy nyilvántartásba helyezi-e vagy sem. Általában a fordítók maguk végeznek különféle optimalizálásokat, amelyek magukban foglalják a változók egy részének a nyilvántartásba helyezését. A C ++ program regiszterváltozóinak száma nincs korlátozva. De lehet, hogy a fordító nem tárolja a változót egy regiszterben. Ennek oka, hogy a regisztrációs memó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 jegyzeteket 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ó állítások. Beilleszthető a C ++ kódba, amely segít bárkinek, aki elolvassa a forráskódját. Minden programozási nyelv lehetővé teszi a megjegyzések valamilyen formáját. A C ++ egy- és többsoros megjegyzéseket egyaránt támogat.


    

  • Az egysoros megjegyzések azok, amelyek // -nel kezdődnek és a sor végéig folytatódnak. Ha egy megjegyzéssor utolsó karaktere \, akkor a megjegyzés a következő sorban folytatódik.
    • 

  • A többsoros megjegyzések azok, amelyek / * -vel kezdődnek és * / -nel végződnek.
    • 



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

Menekülési szekvenciák


Egyes karakterek, például a visszalépés és a vezérlő karakterek, nem rendelkeznek látható képpel. Az ilyen karaktereket nem nyomtatható karaktereknek nevezzük. Más karakterek (egy- és dupla idézőjelek, kérdőjel és visszavágás) különleges jelentéssel bírnak a sok programozási nyelvben.


Programjaink nem képesek közvetlenül használni ezeket a karaktereket. Ehelyett használhatunk egy menekülési szekvenciát az ilyen jellegzetesség képviseletére. A menekülési sorrend visszavágással kezdődik.


A C ++ programozási nyelv számos menekülési szekvenciát határoz meg:


 

 

 

Mit csinal?

 

karakter

 


 

 

Új sor

 

\ n

 


 

 

Függőleges fül

 

\ v

 


 

 

Visszavágás

 

\\

 


 

 

Kocsi vissza

 

\ r

 


 

 

Vízszintes fül

 

\ t

 


 

 

Backspace

 

\ b

 


 

 

Kérdőjel

 

\?

 


 

 

Formfeed

 

\ f

 


 

 

Riasztás (csengő)

 

\ a

 


 

 

Dupla idézet

 

\ "

 


 

 

Egyetlen idézet

 

\ '

 


 

 



Menekülési sorrendet használunk, mintha egyetlen karakter lenne:


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


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


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


Használhatunk előre definiált menekülési szekvenciákat, mint bármely más karaktert.


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


Összegzés


    

  • A C ++ változó megnevezett tárolási lehetőséget biztosít számunkra.
    • 

  • C ++ változó típusok: int, double, char, float, string, bool stb.
    • 

  • A tartalmazott (vagy beágyazott) hatókört belső hatókörnek nevezzük, a benne lévő hatókör pedig a külső hatókörnek.
    • 

  • Egy típusú változó átalakítható másikká. "Típusátalakítás" néven ismert.
    • 

  • A regiszter változókhoz a memóriaváltozókhoz képest gyorsabban lehet hozzáférni.
    • 

  • A megjegyzések a kód azon részei, amelyeket a fordító figyelmen kívül hagy.
    • 

  • Egyes karakterek, például a visszalépés és a vezérlő karakterek, nem rendelkeznek látható képpel.
    •