C++ Variabler och typer: Int, Char, Float, Double, String & Bool

C++ Variabla datatyper

C++ definierar en hel uppsättning primitiva typer

Smakämnen ogiltig typ har inga associerade värden med sig och kan användas i endast ett fåtal omständigheter. Det är oftast som returtyp av funktioner som inte returnerar ett värde.

Smakämnen aritmetiska typer inkluderar tecken, heltal, booleska värden och flyttal. Aritmetisk typ om ytterligare uppdelad i 2 kategorier

1. Flyttalstyper. Float (eller flytande typ) representerar decimaltal. IEEE-standarden specificerar ett minsta antal signifikanta siffror. De flesta kompilatorer ger vanligtvis mer precision än det angivna minimumet. Vanligtvis representeras flöten med 32 bitar, dubblar i 64 bitar och långa dubblar i antingen 96 eller 128 bitar.
2. Integraltyper (som inkluderar tecken, heltal och booleska typer). De Boolean typ har bara två typer av värden: True eller False. Det finns flera röding typer, av vilka de flesta finns för att stödja internationalisering. Den mest grundläggande karaktärstypen är char. En char är samma storlek som en enda maskinbyte, vilket betyder en enda byte.

Smakämnen Integraltyper kan vara undertecknad eller osignerad.

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

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

Variabelnamn eller identifierare

Identifierare kan bestå av vissa bokstäver, siffror och understreckstecken eller någon kombination av dem. Ingen begränsning sätts för namnlängden.

Identifierare måste

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

// definierar fyra olika int-variabler

int guru99, gurU99, GuRu99, GURU99;

Smakämnen 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. Att följa dessa konventioner kan förbättra programmets läsbarhet.

• En identifierare bör ge åtminstone en viss indikation på dess betydelse.
• Variabelnamn ä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 bör visuellt särskilja varje ord. 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 i det omfång som det definieras i. Exempel:

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

int a,b;
a=b=1000;

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

Const Kval in 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 bör ä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 vara obligatoriskt att deklareras och initieras. Annars ger kompilatorn ett fel.

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 

Omfattning av variabler i C++

Ett scope är ett span av ett program där en variabel har en betydelse. Oftast 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 deras deklaration visas.

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

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 namnområdet - cout och endl.

• Funktionsnamnet "main" definieras utanför de lockiga klammerparenteserna. Funktionsnamnet main – liksom de flesta andra namn som definieras utanför en funktion – har ett globalt omfång. Vilket betyder att en gång deklarerats, namn som finns på global räckvidd är tillgängliga genom hela programmet.
• Variabelsumman definieras inom ramen för blocket som är huvudfunktionens kropp. Den kan nås från dess deklarationsplats och genom resten av huvudfunktionens organ. Dock inte utanför det. Detta innebär att variabel summa har blockera omfattning.
• Variabeln val definieras inom ramen för "för uttalande". Det kan lätt användas i det uttalandet men inte någon annanstans i huvudfunktionen. Det har lokal omfattning.

Kapslad omfattning

Omfattningen kan innehålla andra omfattningar. Det inneslutna (eller kapslade) omfånget kallas ett inre omfång. Det innehållande omfånget är det yttre omfånget.

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

Utgång #1 visas före den lokala definitionen av återanvändning. Alltså denna utgång

satsen är den som använder det återanvända namnet som är definierat i globalt omfång. Detta uttalande utdata

42 0

Utgång #2 inträffar efter den lokala definitionen av återanvändning. Det är nu i omfattning. Därför använder denna andra utdatasats helt enkelt det lokala objektet med namnet återanvänd snarare än globalt och utdata

0 0

Utgång #3 åsidosätter standardomfattningsreglerna med hjälp av scope operator. Den globala omfattningen har inget namn. Således, när scope-operatorn(::) har en tom vänster sida. Den tolkar det som en begäran om att hämta namnet på höger sida av det globala omfånget. Således använder uttrycket den globala återanvända och utdata

42 0

Variabel typkonvertering

En variabel av en typ kan konverteras till en annan. Det är känt som "Typomvandling". Låt oss se reglerna för att konvertera olika C++ variabeltyper:

Tilldelning av icke-bool till en bool-variabel ger falskt om värdet är 0 och annars sant.

bool b = 42;            // b is true

Att tilldela en bool till en av de andra aritmetiktyperna ger 1 om boolen är sann och 0 om boolen är falsk.

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

Att tilldela ett flyttalsvärde till en variabel av int-typ ger värdet som trunkeras. Värdet som lagras är delen före decimalkomma.

int i = 3.14;               // i has value 3

Tilldelning av ett int-värde till en variabel av floattyp resulterar i att bråkdelen blir noll. Precisionen går vanligtvis förlorad om heltalet har fler bitar än vad den flytande variabeln kan ta emot.

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 typen utan tecken, blir resultatet resten av värdet %(modulo)

Till exempel kan en 8-bitars osignerad teckentyp innehålla värden från 0 till och med 255. Att tilldela ett värde utanför detta intervall kommer att resultera i att kompilatorn tilldelar resten av det värdet modulo 256. Därför, enligt logiken ovan, tilldelning av –1 till ett 8-bitars osignerat tecken 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 teckentyp är resultatet oförutsägbart. Det är odefinierat. Programmet kan tyckas fungera på utsidan, eller det kan krascha, eller det kan producera skräpvärden.

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

Kompilatorn tillämpar samma typ av konverteringar 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 true
i = 0; 

Om detta värde = 0, är ​​villkoret falskt; alla andra (ej noll) värden ger sanna. 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 oftast nästan säkert felaktigt att använda en bool i ett aritmetiskt uttryck.

Varning: Blanda inte signerade och osignerade typer

Uttryck som blandar signerat och osignerat kan ge överraskande och felaktiga resultat när det signerade värdet är negativt. Som diskuterats ovan konverteras teckenvä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 utan tecken 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 att komma åt jämfört med minnesvariabler. Så, variabler som ofta används i en C++ program kan läggas in i register med hjälp av registrera nyckelord. Registernyckelordet talar om för kompilatorn att lagra den givna variabeln i ett register. Det är kompilatorns val om den ska läggas in i ett register eller inte. Generellt gör kompilatorer själva olika optimeringar som inkluderar att lägga in några av variablerna i registret. Det finns ingen gräns för antalet registervariabler i en C++ programmera. 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 tillåter 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 påståenden. Det kan ingå i C++ kod som hjälper alla att läsa dess källkod. Alla programmeringsspråk tillåter någon form av kommentarer. C++ stöder både enkelradiga och flerradiga kommentarer.

• Enradiga kommentarer är de som börjar med // och fortsätter till slutet av raden. Om det sista tecknet i en kommentarsrad är en \ så fortsätter kommentaren på nästa rad.
• Flerradiga kommentarer är de som börjar med /* och slutar med */.

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

Escape Sequences

Vissa tecken, som backsteg 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 snedstreck) 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 flyktsekvens för att representera sådan char. En flyktsekvens börjar med ett snedstreck.

Smakämnen C++ programmeringsspråk definierar flera flyktsekvenser:

Vad gör den?	Karaktär
Ny linje	\n
Vertikal flik	\v
bakstreck	\\
Vagnretur	\r
Horisontell flik	\t
Backsteg	\b
Frågetecken	\?
Formfeed	\f
Alert (klocka)	\a
Double citera	\ ”
Enstaka citat	\ '

Vi använder en escape-sekvens som om det vore ett enda tecken:

cout << '\n';        // prints a newline
cout << "\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 en \ följt av en, eller två eller tre oktala siffror. Den generaliserade escape-sekvensen representerar tecknets numeriska värde. Några exempel (förutsatt att Latin-1 char set):

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

Vi kan använda fördefinierade escape-sekvenser, eftersom vi använder vilket annat tecken som helst.

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

Sammanfattning

• A C++ variabel ger oss en namngiven lagringskapacitet.
• C++ variabeltyper: int, dubbel, röding, flyta, snöre, bool, etc.
• Det inneslutna (eller kapslade) omfånget hänvisas till som ett inre omfång, och det innehållande omfånget är det yttre omfånget.
• En variabel av en typ kan konverteras till en annan. Det är känt som "Typomvandling".
• Registervariabler är snabbare att komma åt jämfört med minnesvariabler.
• Kommentarer är de delar av koden som ignoreras av kompilatorn.
• Vissa tecken, som backsteg och kontrolltecken, har ingen synlig bild.