C ++ variabler och typer: int, dubbel, char, sträng, bool

Variabler i C ++

En C ++ -variabel ger oss en namngiven lagringsfunktion. Det gör det möjligt för programmeraren att manipulera data enligt behovet. Varje variabel har en typ i C ++. Variabeltypen hjälper till att bestämma storleken och layouten på variabelns minneskarta, det värdeområde som kan lagras i minnet och den uppsättning funktioner som kan tillämpas på den.

I denna C ++ -handledning lär du dig:

Variabler i C ++
Grundläggande typer av variabler i C ++
Regler för deklarationsvariabler i C ++
C ++ variabla datatyper
Variabelt namn eller identifierare
Const Qualifier i C ++
Omfattning av variabler i C ++
Variabel typkonvertering
Registrera variabler
Escape sekvenser

Grundläggande typer av variabler i C ++

Här är de grundläggande typerna av C ++ - variabler:

Int:

Ett heltal är en numerisk bokstav (associerad med tal) utan någon bråkdel eller exponentiell del. Exempel. 120, -90, etc.

Dubbel:

Det är ett flytande punktvärde med dubbel precision. Exempel: 11.22, 2.345

Röding:

En bokstav skapas genom att en enda karaktär omges av enstaka citattecken. Till exempel: 'a', 'm', 'F', 'P', '}' etc.

Flyta:

En bokstav med flytande punkt är en numerisk bokstav som antingen har en bråk- eller exponentform. Till exempel: 1.3, 2.6

Stränglitteratur:

En sträng bokstavlig är en sekvens av tecken inneslutna i dubbla citattecken. Till exempel: "Hur mår du?"

Bool:

Det håller booleskt värde sant eller falskt.

Regler för deklarationsvariabler i C ++

Här är några vanliga regler för att namnge en variabel:

Ett C ++ -variabelt namn kan bara ha alfabet, siffror och understrykning.
Ett C ++ -variabelt namn kan inte börja med ett tal.
Variabla namn bör inte börja med ett stort tecken.
Ett variabelnamn som används i C ++ kan inte vara ett nyckelord. Int är till exempel ett nyckelord som används för att beteckna heltal.
Ett C ++ -variabelt namn kan börja med en understrykning. Det anses dock inte vara en bra praxis.

C ++ variabla datatyper

C ++ definierar en hel uppsättning primitiva typer

Det tomrum typ har inget samband värden med det och kan användas i endast ett fåtal omständigheter. Det är oftast som returtyp av funktioner som inte returnerar ett värde.

De aritmetiska typerna inkluderar tecken, heltal, booleska värden och flytande siffror. Aritmetisk typ om ytterligare uppdelad i två kategorier

Flytpunktstyper . Float (eller flytande typ) representerar decimaltal. IEEE-standarden anger ett minimum antal signifikanta siffror. De flesta kompilatorer ger vanligtvis mer precision än det angivna minimumet. Vanligtvis representeras flottör av 32 bitar, dubblar i 64 bitar och långa dubblar i antingen 96 eller 128 bitar.
Integrala typer (som inkluderar tecken, heltal och booleska typer). Den booleska typen har bara två typer av värden: sant eller falskt. Det finns flera rödingstyper , varav de flesta finns för att stödja internationalisering. Den mest grundläggande karaktärstypen är char. En röding har samma storlek som en enda maskinbyte vilket betyder en enda byte.

De Integral typerna kan undertecknas eller osignerade.

Signerad typ : De representerar negativa eller positiva tal (inklusive noll). I en signerad typ måste intervallet delas jämnt mellan + ve- och -ve-värden. Således kommer en 8-bitars signerad char att innehålla värden från -127 till 127.

Osignerad typ : I en osignerad typ är alla värden> = 0. En 8-bitars osignerad karaktär kan innehålla 0 till 255 (båda inklusive).

Variabelt namn eller identifierare

Identifierare kan bestå av några bokstäver, siffror och understrykningstecknet eller en kombination av dem. Inga gränser införs för namnlängden.

Identifierare måste

börja med antingen en bokstav eller en understrykning ('_').
Och är skiftlägeskänsliga; stora och små bokstäver är olika:

// definierar fyra olika int-variabler

int guru99, gurU99, GuRu99, GURU99;

C ++ - språket har reserverat några namn för dess användning.

Det finns många accepterade konventioner för att namnge variabler i olika programmeringsspråk. Genom att följa dessa konventioner kan programmet förbättra läsbarheten.

En identifierare bör ge åtminstone en viss indikation på dess betydelse.
Variabla namn är vanligtvis gemener-guru99, inte Guru99 eller GURU99.
De klasser vi definierar börjar vanligtvis med en stor bokstav.
Identifierare som innehåller flera ord ska skilja varje ord visuellt. Till exempel guru99_website inte guru99website.

C ++ variabel deklaration och definition

En deklaration av en variabel gör ett namn känt för programmet inom det omfång det definieras i. Exempel:

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

int a,b;a=b=1000;

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

Const Qualifier i C ++

Anta att det finns en variabel buffsize som anger antalet ingångar som ska tas från användaren. Här vill vi inte ändra värdet på buffsize genom hela programmet. Vi vill definiera en variabel vars värde vi vet inte ska ändras.

Använd i så fall nyckelordet const

const int bufSize = 512; // input buffer size

Detta definierar bufSize som en konstant. Varje försök att tilldela eller ändra bufSize ger ett fel.

Här kan vi inte ändra värdet på ett const-objekt efter att vi skapat det, det måste obligatoriskt deklareras och initialiseras. Annars ger kompilatorn ett fel.

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

Omfattning av variabler i C ++

Ett omfång är ett intervall för ett program där en variabel har en mening. För det mesta kan samma namn användas för att referera till olika enheter inom olika omfattningar. Variabler är synliga från den punkt där de deklareras till slutet av det omfång där deklarationen visas.

#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 <
Detta program definierar 3 namn, nämligen, huvud, summa och val. Den använder namnutrymmets namn std, tillsammans med två andra namn från det namnutrymmet och endl.

Funktionsnamnet "huvud" definieras utanför de lockiga hakparenteserna. Funktionsnamnet, som de flesta andra namn som definieras utanför en funktion, har ett globalt omfång. Vilket innebär att namn som är globalt tillgängliga när de väl deklareras är tillgängliga i hela programmet.
Den variabla summan definieras inom ramen för blocket som är huvudfunktionens huvuddel. Det kan nås från dess deklarationspunkt och genom resten av huvudfunktionens kropp. Men inte utanför det. Detta innebär att variabel summa har blockomfång .
Variabeln val definieras i ramen för "för uttalande". Det kan lätt användas i det uttalandet men inte någon annanstans i huvudfunktionen. Den har lokal räckvidd .

Nested Scope
Omfattningen kan innehålla andra omfattningar. Det inneslutna (eller kapslade) omfattningen kallas ett inre omfång. Det innehållande omfånget är det yttre omfånget.
#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;}
Output # 1 visas före den lokala definitionen av återanvändning. Således denna produktion
uttalande är det som använder namnet återanvänt som definieras i globalt omfång. Detta uttalande matas ut
42 0
Output # 2 sker efter den lokala definitionen av återanvändning. Det är nu inom räckvidden. Därför använder detta andra utgångsuttalande helt enkelt det lokala objekt som heter återanvänds snarare än globalt och utdata
0 0
Utgång # 3 åsidosätter standardregleringsreglerna med scope-operatören. Det globala omfånget har inget namn. Således när scope-operatören (: :) har en tom vänster sida. Det tolkar det som en begäran om att hämta namnet till höger om det globala omfånget. Således använder uttrycket den globala återanvändningen och utdata
42 0

Variabel typkonvertering
En variabel av en typ kan omvandlas till en annan. Det är känt som "Type Conversion." Låt oss se reglerna för konvertering av olika C ++ -variabeltyper:
Tilldelning av icke-bool till en bool-variabel ger falskt om värdet är 0 och sant annars.
bool b = 42; // b is true
Att tilldela en bool till en av de andra aritmetiska typerna ger 1 om bool är sant och 0 om bool är falskt.
bool b = true;int i = b; // i has value 1
Att tilldela ett variabelt värde till en variabel av int-typ ger det värde som trunkeras. Värdet som lagras är delen före decimalpunkten.
int i = 3.14; // i has value 3
Tilldelning av ett intvärde till en variabel av flottörtyp resulterar i att bråkdelen blir noll. Precision försvinner vanligtvis om heltalet har fler bitar än den flytande variabeln rymmer.
Int i=3;double pi = i; // pi has value 3.0
Om vi försöker tilldela ett värde utanför intervallet till en variabel av osignerad typ är resultatet resten av värdet% (modulo)
Till exempel kan en 8-bitars osignerad char-typ innehålla värden från 0 till 255 inklusive. Att tilldela ett värde utanför detta område kommer att resultera i att kompilatorn tilldelar återstoden av det värdet modulo 256. Därför, genom logiken ovan, tilldelning av -1 till en 8-bitars osignerad char ger det objektet värdet 255.
unsigned char c = -1; // assuming 8-bit chars, c has value 255
Om vi försöker tilldela ett värde utanför intervallet till ett objekt av signerad typ är resultatet oförutsägbart. Det är odefinierat. Programmet kan verka fungera på utsidan, eller så kan det krascha, eller så kan det producera skräpvärden.
signed char c2 = 256; // assuming 8-bit chars, the value of c2 is undefined
Kompilatorn använder samma typ av omvandlingar när vi använder ett värde av en typ där ett värde av en annan typ förväntas.
int i = 42;if (i) // condition will evaluate as truei = 0;
Om detta värde = 0 är villkoret falskt; alla andra (icke-noll) värden ger sant. Enligt samma koncept, när vi använder en bool i ett aritmetiskt uttryck, omvandlas dess värde alltid till antingen 0 eller 1. Som ett resultat är det vanligtvis nästan säkert felaktigt att använda en bool i ett aritmetiskt uttryck.
Varning: Blanda inte signerade och osignerade typer
Uttryck som blandar signerade och osignerade kan ge överraskande och fel resultat när det signerade värdet är negativt. Som diskuterats ovan konverteras signerade värden automatiskt till osignerade.
Till exempel i ett aritmetiskt uttryck som
x* y
Om x är -1 och y är 1, och om både x och y är int, är värdet som förväntat -1.
Om x är int och y är osignerade beror värdet på detta uttryck på hur många bitar ett heltal har på kompileringsmaskinen. På vår maskin ger detta uttryck 4294967295.

Registrera variabler
Registervariabler är snabbare åtkomliga jämfört med minnesvariabler. Så variabler som ofta används i ett C ++ - program kan placeras i register med hjälp av registernyckelord . Registernyckelordet ber kompilatorn att lagra den angivna variabeln i ett register. Det är kompilatorns val om du vill lägga det i ett register eller inte. Generellt gör kompilatorer själva olika optimeringar som inkluderar att placera några av variablerna i registret. Det finns ingen gräns för antalet registervariabler i ett C ++ - program. Men kompilatorn kanske inte lagrar variabeln i ett register. Detta beror på att registerminnet är mycket begränsat och oftast används av operativsystemet.
Att definiera:
register int i;
Kommentarer
Kommentarer är de delar av koden som ignoreras av kompilatorn. Det gör det möjligt för programmeraren att göra anteckningar i de relevanta områdena i källkoden / programmet. Kommentarer kommer antingen i blockform eller enstaka rader. Programkommentarerna är förklarande uttalanden. Den kan inkluderas i C ++ - koden som hjälper alla som läser källkoden. Alla programmeringsspråk tillåter någon form av kommentarer. C ++ stöder både enradiga och flerradiga kommentarer.

Kommentarer med en rad är de som börjar med // och fortsätter till slutet av raden. Om det sista tecknet i en kommentarrad är a \ fortsätter kommentaren i nästa rad.
Kommentarer med flera rader är de som börjar med / * och slutar med * /.

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

Escape sekvenser
Vissa karaktärer, såsom bakre utrymme och kontrolltecken, har ingen synlig bild. Sådana tecken är kända som icke-utskrivbara tecken. Andra tecken (enkla och dubbla citattecken, frågetecken och backslash) har speciell betydelse i de många programmeringsspråken.
Våra program kan inte använda någon av dessa karaktärer direkt. Istället kan vi använda en escape-sekvens för att representera en sådan char. En escape-sekvens börjar med en backslash.
Programmeringsspråket C ++ definierar flera escape-sekvenser:

Vad gör den?

Karaktär

Ny linje

\ n

Vertikal flik

\ v

Backslash

Vagnretur

\ r

Horisontell flik

\ t

Backspace

\ b

Frågetecken

Formfeed

\ f

Varning (klocka)

\ a

Dubbel offert

\ "

Enkel offert

\ '

Vi använder en escape-sekvens som om det vore en enda karaktär:
cout << '\n'; // prints a newlinecout << "\tguru99!\n"; // prints a tab followed by "guru99!" and a newline
Vi kan också skriva generaliserade escape-sekvenser \ x följt av en eller flera hexadecimala siffror. Eller så använder vi a \ följt av en, två eller tre oktala siffror. Den generaliserade escape-sekvensen representerar karaktärens numeriska värde. Några exempel (förutsatt att Latin-1-teckenuppsättningen):
\7 (bell) \12 (newline) \40 (blank)\0 (null) \115 ('M') \x4d ('M')
Vi kan använda fördefinierade escape-sekvenser, eftersom vi använder alla andra tecken.
cout << "Hi \x4dO\115!\n"; // prints Hi MOM! followed by a newlinecout << '\115' << '\n'; // prints M followed by a newline
Sammanfattning

En C ++ -variabel ger oss en namngiven lagringsfunktion.
C ++ variabeltyper: int, double, char, float, string, bool, etc.
Det inneslutna (eller kapslade) omfånget kallas ett inre omfång, och det innehållande omfånget är det yttre omfånget.
En variabel av en typ kan omvandlas till en annan. Det är känt som "Type Conversion."
Registervariabler är snabbare åtkomliga jämfört med minnesvariabler.
Kommentarer är de delar av koden som ignoreras av kompilatorn.
Vissa karaktärer, såsom bakre utrymme och kontrolltecken, har ingen synlig bild.