C++ Muutujad ja tüübid: Int, Char, Float, Double, String & Bool

C++ Muutuvad andmetüübid

C++ defineerib terve hulga primitiivseid tüüpe

. tühine tüübil pole sellega seotud väärtusi ja seda saab kasutada vaid mõnel juhul. Enamasti on see funktsioonide tagastamistüüp, mis väärtust ei tagasta.

. aritmeetilised tüübid sisaldab märke, täisarve, Boole'i ​​väärtusi ja ujukoma numbreid. Aritmeetiline tüüp, kui jagada veel kahte kategooriasse

1. Ujukomatüübid. Ujuk (või ujuv tüüp) tähistab kümnendarvu. IEEE standard määrab minimaalse arvu olulisi numbreid. Enamik kompilaatoreid pakuvad tavaliselt määratud miinimumist suuremat täpsust. Tavaliselt on ujukid esindatud 32-bitiseid, kahekordseid 64-bitise ja pikki kahekordseid 96 või 128 bitte.
2. Integraalsed tüübid (mis sisaldavad märke, täisarve ja Boole'i ​​tüüpe). The Boolean tüübil on ainult kahte tüüpi väärtusi: True või False. Neid on mitu sõjavanker tüübid, millest enamik eksisteerib rahvusvahelistumise toetamiseks. Kõige elementaarsem märgitüüp on char. Char on sama suur kui üks masinabait, mis tähendab ühte baiti.

. Integraalsed tüübid võib olla allkirjastatud või allkirjastamata.

Signeeritud tüüp: need tähistavad negatiivseid või positiivseid arve (sh null). Märgiga tüübi puhul peab vahemik olema ühtlaselt jagatud +ve ja -ve väärtuste vahel. Seega hoiab 8-bitine märgiga tähemärk väärtusi vahemikus –127 kuni 127.

Signeerimata tüüp: märgita tüübi puhul on kõik väärtused >= 0. 8-bitine märgita märk võib sisaldada 0 kuni 255 (mõlemad kaasa arvatud).

Muutuja nimi või identifikaatorid

Identifikaatorid võivad koosneda mõnest tähest, numbrist ja allkriipsust või nende kombinatsioonist. Nime pikkusele pole piiranguid seatud.

Identifikaatorid peavad

• algavad kas tähe või alakriipsuga ('_').
• Ja on tõstutundlikud; suured ja väikesed tähed erinevad:

// defineerib neli erinevat int muutujat

int guru99, gurU99, GuRu99, GURU99;

. C++ keel on reserveerinud oma kasutamiseks mõned nimed.

Muutujate nimetamiseks on palju aktsepteeritud tavasid erinevad programmeerimiskeeled. Nende tavade järgimine võib parandada programmi loetavust.

• Identifikaator peaks selle tähendusest vähemalt mingil määral viitama.
• Muutujate nimed on tavaliselt väiketähtedega — guru99, mitte Guru99 või GURU99.
• Meie määratletud klassid algavad tavaliselt suure tähega.
• Mitut sõna sisaldavad identifikaatorid peaksid iga sõna visuaalselt eristama. Näiteks guru99_website, mitte guru99website.

C++ Muutuja deklaratsioon ja definitsioon

Muutuja deklaratsioon teeb programmile nime teatavaks selles ulatuses, milles see on määratletud. Näide:

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

int a,b;
a=b=1000;

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

Const kvalifikatsioon sisse C++

Oletame, et on olemas muutuja buffsize, mis määrab kasutajalt võetavate sisendite arvu. Siin ei taha me muuta buffsize väärtust kogu programmi jooksul. Tahame määratleda muutuja, mille väärtust me teame, et see ei tohiks muutuda.

Sellisel juhul kasutage märksõna const

const int bufSize = 512;    // input buffer size

See määratleb bufSize kui konstandi. Iga katse bufSize'i määrata või muuta annab vea.

Siin ei saa me pärast loomist const-objekti väärtust muuta, selle deklareerimine ja initsialiseerimine peab olema kohustuslik. Vastasel juhul annab kompilaator vea.

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 

Muutujate ulatus C++

Ulatus on programmi ulatus, kus muutujal on tähendus. Enamasti saab sama nime kasutada erinevate üksuste viitamiseks erinevates ulatustes. Muutujad on nähtavad nende deklareerimise kohast kuni selle ulatuse lõpuni, milles nende deklaratsioon ilmub.

#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;	
}	 

See programm määratleb 3 nime, nimelt, main, summa ja val. See kasutab nimeruumi nime std koos kahe teise selle nimeruumi nimega – cout ja endl.

• Funktsiooni nimi “main” on määratletud väljaspool lokkis sulgusid. Funktsiooni nimi main – nagu enamik muid väljaspool funktsiooni määratletud nimesid – on globaalse ulatusega. Mis tähendab, et kui on kuulutatud, siis nimed, mis on juures globaalne ulatus on kättesaadavad kogu programmi jooksul.
• Muutuv summa määratakse ploki ulatuses, mis on põhifunktsiooni põhiosa. Sellele pääseb juurde selle deklareerimiskohast ja kogu ülejäänud põhifunktsiooni korpusest. Siiski mitte väljaspool seda. See tähendab, et muutuv summa on ploki ulatus.
• Muutuja val on määratletud "for lausendi" ulatuses. Seda saab hõlpsasti kasutada selles avalduses, kuid mitte mujal põhifunktsioonis. On kohalik ulatus.

Pesastatud ulatus

Ulatus võib sisaldada muid ulatuseid. Sisalduvat (või pesastatud) ulatust nimetatakse sisemiseks ulatuseks. Sisaldav ulatus on välimine ulatus.

#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;	
}	 

Väljund nr 1 ilmub enne kohalikku taaskasutatud määratlust. Seega see väljund

avaldus on see, mis kasutab globaalses ulatuses määratletud nime uuesti kasutatud. See väide annab välja

42 0

Väljund nr 2 tekib pärast taaskasutamise kohalikku määratlust. See on nüüd kohaldamisalas. Seetõttu kasutab see teine ​​väljundlause lihtsalt kohalikku objekti nimega taaskasutatud, mitte globaalset ja väljub

0 0

Väljund nr 3 alistab ulatuse vaikereeglid, kasutades ulatuse operaator. Globaalsel ulatusel pole nime. Seega, kui ulatuse operaatori (::) vasak pool on tühi. See tõlgendab seda kui globaalse ulatuse paremas servas oleva nime toomise taotlust. Seega kasutab avaldis globaalset taaskasutamist ja väljundeid

42 0

Muutuja tüübi teisendamine

Ühte tüüpi muutuja saab teisendada teiseks. Seda tuntakse kui "tüübi teisendamist". Vaatame erinevate teisendamise reegleid C++ muutuvad tüübid:

Mittetõendi määramine tõeväärtuse muutujale annab vale, kui väärtus on 0, ja tõene muul juhul.

bool b = 42;            // b is true

Tõene määramine mõnele muule aritmeetilisele tüübile annab 1, kui tõend on tõene ja 0, kui tõend on väär.

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

Ujukoma väärtuse määramine int tüüpi muutujale annab väärtuse, mis kärbitakse. Salvestatud väärtus on koma ees olev osa.

int i = 3.14;               // i has value 3

Ujuktüüpi muutujale int väärtuse määramine toob kaasa selle, et murdosa muutub nulliks. Tavaliselt läheb täpsus kaotsi, kui täisarvul on rohkem bitte, kui ujuvmuutuja mahutab.

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

Kui proovime määrata vahemikust väljapoole jäävat väärtust märgita tüüpi muutujale, on tulemuseks väärtuse ülejäänud osa %(modulo)

Näiteks 8-bitine märgita märgitüüp võib sisaldada väärtusi vahemikus 0 kuni 255 (kaasa arvatud). Sellest vahemikust väljapoole jääva väärtuse määramisel määrab kompilaator ülejäänud osa sellest väärtusest mooduli 256. Seetõttu annab ülaltoodud loogika kohaselt –1 määramine 8-bitisele märgita märgile sellele objektile väärtuse 255.

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

Kui proovime allkirjaga objektile omistada vahemikust väljapoole jäävat väärtust, on tulemus ettearvamatu. See on määratlemata. Võib tunduda, et programm töötab väljastpoolt või jookseb kokku või võib tekitada prügiväärtusi.

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

Kompilaator rakendab sama tüüpi konversioone, kui kasutame ühte tüüpi väärtust, kui eeldatakse teist tüüpi väärtust.

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

Kui see väärtus = 0, siis on tingimus väär; kõik muud (nullist erinevad) väärtused annavad tõene. Sama kontseptsiooni järgi, kui me kasutame aritmeetilises avaldises tõeväärtust, teisendatakse selle väärtus alati kas 0-ks või 1-ks. Selle tulemusena on tõeväärtuse kasutamine aritmeetilises avaldises tavaliselt peaaegu kindlasti vale.

Ettevaatust: ärge segage allkirjastatud ja allkirjastamata tüüpe

Märgiga ja märgita avaldised võivad anda üllatavaid ja valesid tulemusi, kui märgiga väärtus on negatiivne. Nagu ülalpool kirjeldatud, teisendatakse märgistatud väärtused automaatselt allkirjastamata väärtusteks.

Näiteks aritmeetilises avaldises nagu

x* y

Kui x on -1 ja y on 1 ning kui nii x kui ka y on int, on väärtus ootuspäraselt -1.

Kui x on int ja y on märgita, siis selle avaldise väärtus sõltub sellest, mitu bitti on täisarvul kompileerimismasinas. Meie masinas annab see avaldis tulemuseks 4294967295.

Registreeri muutujad

Registrite muutujatele on mälumuutujatega võrreldes kiirem juurdepääs. Niisiis, muutujad, mida sageli kasutatakse a C++ programmi saab panna registritesse kasutades registreerima märksõna. Registri märksõna käsib kompilaatoril antud muutuja registrisse salvestada. See on koostaja valik, kas panna see registrisse või mitte. Üldiselt teevad kompilaatorid ise mitmesuguseid optimeerimisi, mis hõlmavad mõne muutuja sisestamist registrisse. Registrimuutujate arv a-s ei ole piiratud C++ programm. Kuid kompilaator ei pruugi muutujat registrisse salvestada. Seda seetõttu, et registrimälu on väga piiratud ja seda kasutab OS kõige sagedamini.

Määratlemiseks:

register int i;

Kommentaarid

Kommentaarid on koodi osad, mida kompilaator ignoreerib. See võimaldab programmeerijal teha märkmeid lähtekoodi/programmi asjakohastes piirkondades. Kommentaarid on kas plokkidena või üksikute ridadena. Programmi kommentaarid on seletuskirjad. Seda saab lisada C++ kood, mis aitab kõigil selle lähtekoodi lugeda. Kõik programmeerimiskeeled lubavad teatud kujul kommentaare. C++ toetab nii ühe- kui ka mitmerealisi kommentaare.

• Üherealised kommentaarid on need, mis algavad tähega // ja jätkuvad rea lõpuni. Kui kommentaarirea viimane märk on \, jätkub kommentaar järgmisel real.
• Mitmerealised kommentaarid on need, mis algavad /* ja lõpevad */-ga.

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

Põgenemisjärjestused

Mõnel tähemärgil, näiteks tagasilükke- ja juhtmärkidel, pole nähtavat pilti. Selliseid märke nimetatakse mitteprinditavateks märkideks. Teistel tähemärkidel (üks- ja topeltjutumärgid, küsimärk ja kaldkriips) on paljudes programmeerimiskeeltes eriline tähendus.

Meie programmid ei saa neid märke otse kasutada. Selle asemel võime sellise tähe esitamiseks kasutada paojärjestust. Põgenemisjärjestus algab kaldkriipsuga.

. C++ programmeerimiskeel määratleb mitu põgenemisjärjestust:

Mida see teeb?	Iseloom
Uus rida	\n
Vertikaalne vahekaart	\v
Lülitus	\\
Vankri tagasipöördumine	\r
Horisontaalne sakk	\t
Backspace	\b
Küsimärk	\?
Vormi sööt	\f
Hoiatus (kell)	\a
Double tsitaat	\ ”
Üksik tsitaat	\ '

Kasutame paojärjestust nii, nagu oleks see üks märk:

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

Võime kirjutada ka üldistatud paojärjestusi \x, millele järgneb üks või mitu kuueteistkümnendsüsteemi numbrit. Või kasutame \, millele järgneb üks, kaks või kolm kaheksandnumbrit. Üldistatud põgenemisjada tähistab märgi arvväärtust. Mõned näited (oletades, et ladina-1 tähemärgikomplekt):

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

Saame kasutada eelmääratletud põgenemisjadasid, nagu me kasutame kõiki teisi märke.

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

kokkuvõte

• A C++ muutuja pakub meile nimega salvestusvõimalust.
• C++ muutujate tüübid: int, double, sõjavanker, ujuki, string, bool jne.
• Sisalduvat (või pesastatud) ulatust nimetatakse sisemiseks ulatuseks ja sisaldavat ulatust välimiseks ulatuseks.
• Ühte tüüpi muutuja saab teisendada teiseks. Seda tuntakse kui "tüübi teisendamist".
• Registrite muutujatele on mälumuutujatega võrreldes kiirem juurdepääs.
• Kommentaarid on koodi osad, mida kompilaator ignoreerib.
• Mõnel tähemärgil, näiteks tagasilükke- ja juhtmärkidel, pole nähtavat pilti.