C++ Variabelen en typen: Int, Char, Float, Double, String & Bool

C++ Variabele gegevenstypen

C++ definieert een hele reeks primitieve typen

De komen te vervallen type heeft geen bijbehorende waarden en kan slechts in enkele omstandigheden worden gebruikt. Het is meestal het retourtype van functies die geen waarde retourneren.

De rekenkundige typen omvatten tekens, gehele getallen, Booleaanse waarden en drijvendekommagetallen. Rekenkundig type indien verder verdeeld in 2 categorieën

1. Typen met drijvende komma. De float (of floating type) representeert decimale getallen. De IEEE standaard specificeert een minimum aantal significante cijfers. De meeste compilers bieden doorgaans meer precisie dan het gespecificeerde minimum. Floats worden doorgaans gerepresenteerd door 32 bits, doubles door 64 bits en long doubles door 96 of 128 bits.
2. Integrale typen (inclusief tekens, gehele getallen en Booleaanse typen). De Boolean type heeft slechts twee soorten waarden: True of False. Er zijn meerdere verkolen soorten, waarvan de meeste bestaan ​​om internationalisering te ondersteunen. Het meest elementaire karaktertype is char. Een char heeft dezelfde grootte als een enkele machinebyte, wat betekent dat het een enkele byte is.

De Integrale typen kan ondertekend of niet-ondertekend zijn.

Ondertekend type: Ze vertegenwoordigen negatieve of positieve getallen (inclusief nul). In een signed type moet het bereik gelijkmatig verdeeld zijn tussen +ve en -ve waarden. Een 8-bit signed char zal dus waarden bevatten van –127 tot en met 127.

Niet-ondertekend type: In een niet-ondertekend type zijn alle waarden >= 0. Een 8-bits teken zonder teken kan 0 tot en met 255 bevatten (beide inclusief).

Variabelenaam of identificatiegegevens

Identificatiegegevens kunnen bestaan ​​uit enkele letters, cijfers en het onderstrepingsteken, of uit een combinatie daarvan. Er wordt geen limiet gesteld aan de naamlengte.

Identificatiegegevens moeten

• beginnen met een letter of een onderstrepingsteken ('_').
• En zijn hoofdlettergevoelig; hoofdletters en kleine letters zijn verschillend:

// definieert vier verschillende int-variabelen

int guru99, gurU99, GuRu99, GURU99;

De C++ taal heeft een aantal namen gereserveerd voor het gebruik ervan.

Er zijn veel geaccepteerde conventies voor het benoemen van variabelen in verschillende programmeertalenDoor deze conventies te volgen, kunt u de leesbaarheid van het programma verbeteren.

• Een identificatie moet op zijn minst enige indicatie geven van de betekenis ervan.
• Variabelenamen zijn meestal in kleine letters: guru99, niet Guru99 of GURU99.
• De klassen die we definiëren beginnen meestal met een hoofdletter.
• ID's die meerdere woorden bevatten, moeten elk woord visueel onderscheiden. Bijvoorbeeld guru99_website en niet guru99website.

C++ Variabele declaratie en definitie

Een declaratie van een variabele maakt een naam bekend aan het programma binnen het bereik waarin deze is gedefinieerd. Voorbeeld:

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

int a,b;
a=b=1000;

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

Const-kwalificatie in C++

Stel dat er een variabele buffsize is die het aantal invoergegevens aangeeft dat van de gebruiker moet worden afgenomen. Hier willen we de waarde van buffsize gedurende het hele programma niet veranderen. We willen een variabele definiëren waarvan we weten dat deze niet mag veranderen.

Gebruik in dat geval het trefwoord const

const int bufSize = 512;    // input buffer size

Dit definieert bufSize als een constante. Elke poging om bufSize toe te wijzen of te wijzigen geeft een foutmelding.

Hier kunnen we de waarde van een const-object niet wijzigen nadat we het hebben gemaakt, het moet verplicht worden gedeclareerd en geïnitialiseerd. Anders geeft de compiler een fout.

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 

Reikwijdte van variabelen in C++

Een scope is een bereik van een programma waarin een variabele een betekenis heeft. Meestal kan dezelfde naam worden gebruikt om naar verschillende entiteiten binnen verschillende bereiken te verwijzen. Variabelen zijn zichtbaar vanaf het punt waarop ze worden gedeclareerd tot het einde van het bereik waarin hun declaratie verschijnt.

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

Dit programma definieert 3 namen, namelijk main, sum en val. Het gebruikt de namespacenaam std, samen met twee andere namen uit die namespace: cout en endl.

• De functienaam “main” wordt buiten de accolades gedefinieerd. De functienaam main heeft, net als de meeste andere namen die buiten een functie zijn gedefinieerd, een globaal bereik. Dat betekent dat, eenmaal aangegeven, namen die op de wereldwijde reikwijdte zijn gedurende het gehele programma toegankelijk.
• De variabele som wordt gedefinieerd binnen de reikwijdte van het blok dat de hoofdtekst van de hoofdfunctie vormt. Het is toegankelijk vanaf het declaratiepunt en in de rest van de hoofdfunctie. Echter niet daarbuiten. Dit betekent dat de variabele som heeft bereik blokkeren.
• De variabele val wordt gedefinieerd in het bereik van “for statement”. Het kan gemakkelijk in die verklaring worden gebruikt, maar niet elders in de hoofdfunctie. Het heeft lokaal bereik.

Genest bereik

Het bereik kan andere bereiken bevatten. Het ingesloten (of geneste) bereik wordt een binnenbereik genoemd. De omvattende reikwijdte is de buitenste reikwijdte.

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

Uitgang #1 verschijnt vóór de lokale definitie van hergebruikt. Deze uitgang dus

statement is degene die de hergebruikte naam gebruikt die is gedefinieerd in de globale reikwijdte. Deze verklaring wordt uitgevoerd

42 0

Uitgang #2 vindt plaats na de lokale definitie van hergebruikt. Het valt nu binnen de reikwijdte. Daarom gebruikt deze tweede uitvoerinstructie eenvoudigweg het lokale object met de naam hergebruikt in plaats van de globale object en uitvoer

0 0

Uitgang #3 overschrijft de standaardbereikregels met behulp van de bereik operator. De globale scope heeft geen naam. Dus wanneer de scope operator(::) een lege linkerkant heeft. Het interpreteert het als een verzoek om de naam op te halen aan de rechterkant van de globale scope. Dus de expressie gebruikt de globale hergebruikt en geeft als output

42 0

Variabele typeconversie

Een variabele van het ene type kan in een ander type worden omgezet. Het staat bekend als ‘Typeconversie’. Laten we eens kijken naar de regels voor het converteren van verschillende C++ variabele typen:

Het toewijzen van een niet-bool-variabele aan een bool-variabele resulteert in false als de waarde 0 is en true als dit niet het geval is.

bool b = 42;            // b is true

Het toewijzen van een bool aan een van de andere rekenkundige typen levert 1 op als de bool waar is en 0 als de bool onwaar is.

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

Het toewijzen van een waarde met drijvende komma aan een variabele van het type int levert de waarde op die wordt afgekapt. De waarde die wordt opgeslagen is het deel vóór de komma.

int i = 3.14;               // i has value 3

Het toekennen van een int-waarde aan een variabele van het float-type heeft tot gevolg dat het fractionele deel nul wordt. Precisie gaat meestal verloren als het gehele getal meer bits heeft dan de zwevende variabele kan bevatten.

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

Als we proberen een waarde toe te wijzen die buiten het bereik valt aan een variabele van het type zonder teken, is het resultaat de rest van de waarde %(modulo)

Een 8-bits tekentype zonder teken kan bijvoorbeeld waarden van 0 tot en met 255 bevatten. Het toewijzen van een waarde buiten dit bereik zal ertoe leiden dat de compiler de rest van die waarde modulo 256 toewijst. Daarom geeft de toewijzing van –1 aan een 8-bits teken zonder teken dat object, volgens de bovenstaande logica, de waarde 255.

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

Als we proberen een waarde buiten het bereik toe te wijzen aan een object van het ondertekende type, is het resultaat onvoorspelbaar. Het is ongedefinieerd. Het programma lijkt aan de buitenkant te werken, het kan crashen, of het kan slechte waarden produceren.

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

De compiler past hetzelfde type conversies toe wanneer we een waarde van het ene type gebruiken terwijl een waarde van een ander type wordt verwacht.

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

Als deze waarde = 0, dan is de voorwaarde onwaar; alle andere (niet-nul) waarden leveren waar op. Volgens hetzelfde concept wordt, wanneer we een bool in een rekenkundige uitdrukking gebruiken, de waarde ervan altijd geconverteerd naar 0 of 1. Als gevolg hiervan is het gebruik van een bool in een rekenkundige uitdrukking meestal vrijwel zeker onjuist.

Let op: Gebruik geen ondertekende en niet-ondertekende typen door elkaar

Uitdrukkingen die ondertekend en niet-ondertekend combineren, kunnen verrassende en verkeerde resultaten opleveren als de ondertekende waarde negatief is. Zoals hierboven besproken, worden ondertekende waarden automatisch geconverteerd naar niet-ondertekend.

Bijvoorbeeld in een rekenkundige uitdrukking zoals

x* y

Als x -1 is en y 1, en als zowel x als y int zijn, dan is de waarde, zoals verwacht, -1.

Als x int is en y geen teken heeft, hangt de waarde van deze uitdrukking af van het aantal bits dat een geheel getal heeft op de compileermachine. Op onze machine levert deze uitdrukking 4294967295 op.

Variabelen registreren

Registervariabelen zijn sneller toegankelijk vergeleken met geheugenvariabelen. Variabelen die vaak worden gebruikt in a C++ programma kan in registers worden geplaatst met behulp van registreren trefwoord. Het registersleutelwoord vertelt de compiler om de gegeven variabele in een register op te slaan. Het is de keuze van de compiler of hij het in een register plaatst of niet. Over het algemeen voeren compilers zelf verschillende optimalisaties uit, waaronder het plaatsen van enkele variabelen in het register. Er is geen limiet op het aantal registervariabelen in a C++ programma. Maar de compiler mag de variabele niet in een register opslaan. Dit komt omdat het registergeheugen zeer beperkt is en meestal door het besturingssysteem wordt gebruikt.

Definiëren:

register int i;

Heb je vragen? Stel ze hier.

Opmerkingen zijn de delen van de code die door de compiler worden genegeerd. Hiermee kan de programmeur aantekeningen maken op de relevante gebieden van de broncode/het programma. Opmerkingen komen in blokvorm of in enkele regels. De programmacommentaar is een toelichting. Het kan worden opgenomen in de C++ code die iedereen helpt bij het lezen van de broncode. Alle programmeertalen staan ​​een vorm van commentaar toe. C++ ondersteunt zowel enkelregelige als meerregelige commentaren.

• Opmerkingen in één regel zijn degenen die beginnen met // en doorgaan tot het einde van de regel. Als het laatste teken in een commentaarregel een \ is, gaat het commentaar verder op de volgende regel.
• Commentaar met meerdere regels zijn degenen die beginnen met /* en eindigen met */.

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

Ontsnappingsreeksen

Sommige tekens, zoals backspace en control-tekens, hebben geen zichtbare afbeelding. Zulke tekens staan ​​bekend als niet-afdrukbare tekens. Andere tekens (enkele en dubbele aanhalingstekens, vraagteken en backslash) hebben een speciale betekenis in de vele programmeertalen.

Onze programma's kunnen deze tekens niet rechtstreeks gebruiken. In plaats daarvan kunnen we een escape-reeks gebruiken om een ​​dergelijke char weer te geven. Een ontsnappingsreeks begint met een backslash.

De C++ programmeertaal definieert verschillende ontsnappingsreeksen:

Wat doet het?	Karakter
Nieuwe lijn	\n
Verticaal tabblad	\v
backslash	\\
Vervoer terug	\r
Horizontaal tabblad	\t
Backspace	\b
Vraagteken	\?
Formulierinvoer	\f
Waarschuwing (bel)	\a
Double citeren	​
Alleenstaande citaat	​

We gebruiken een escape-reeks alsof het één enkel teken is:

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

We kunnen ook gegeneraliseerde ontsnappingsreeksen \x schrijven, gevolgd door een of meer hexadecimale cijfers. Of we gebruiken een \ gevolgd door één, twee of drie octale cijfers. De gegeneraliseerde ontsnappingsreeks vertegenwoordigt de numerieke waarde van het teken. Enkele voorbeelden (uitgaande van de Latin-1 tekenset):

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

We kunnen vooraf gedefinieerde ontsnappingsreeksen gebruiken, net zoals we elk ander teken gebruiken.

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

Samenvatting

• A C++ variabele biedt ons een benoemde opslagmogelijkheid.
• C++ variabelentypen: int, double, verkolen, float, string, bool, enz.
• Het ingesloten (of geneste) bereik wordt een binnenbereik genoemd, en het bevattende bereik is het buitenbereik.
• Een variabele van het ene type kan in een ander type worden omgezet. Het staat bekend als ‘Typeconversie’.
• Registervariabelen zijn sneller toegankelijk vergeleken met geheugenvariabelen.
• Opmerkingen zijn de delen van de code die door de compiler worden genegeerd.
• Sommige tekens, zoals backspace- en controletekens, hebben geen zichtbare afbeelding.