C ++ variabelen en typen: int, double, char, string, bool

Variabelen in C ++

Een C ++ -variabele geeft ons een benoemde opslagcapaciteit. Hiermee kan de programmeur gegevens manipuleren volgens de behoefte. Elke variabele heeft een type in C ++. Het type variabele helpt bij het bepalen van de grootte en lay-out van de geheugentoewijzing van de variabele, het bereik van waarden dat in dat geheugen kan worden opgeslagen en de reeks bewerkingen die erop kunnen worden toegepast.

In deze C ++ tutorial leer je:

• Variabelen in C ++
• Basistypen variabelen in C ++
• Regels voor het declareren van variabelen in C ++
• C ++ Variabele gegevenstypen
• Variabelenaam of ID's
• Const Qualifier in C ++
• Bereik van variabelen in C ++
• Conversie van variabele typen
• Registreer variabelen
• Escape-reeksen

Basistypen variabelen in C ++

Dit zijn de basistypen van C ++ -variabelen:

Int:

Een geheel getal is een numerieke letterlijke waarde (geassocieerd met getallen) zonder een fractioneel of exponentieel deel. Voorbeeld. 120, -90, enz.

Dubbele:

Het is een drijvende-kommawaarde met dubbele precisie. Voorbeeld: 11.22, 2.345

Char:

Een letterlijk teken wordt gemaakt door een enkel teken tussen enkele aanhalingstekens te plaatsen. Bijvoorbeeld: 'a', 'm', 'F', 'P', '}' etc.

Vlotter:

Een letterlijke drijvende-komma is een numerieke letterlijke letter die een breukvorm of een exponentvorm heeft. Bijvoorbeeld: 1.3, 2.6

Letterlijke tekenreeksen:

Een letterlijke tekenreeks is een reeks tekens tussen dubbele aanhalingstekens. Bijvoorbeeld: "Hoe gaat het?"

Bool:

Het bevat de Booleaanse waarde true of false.

Regels voor het declareren van variabelen in C ++

Hier zijn enkele algemene regels voor het benoemen van een variabele:

• Een C ++ - variabelenaam mag alleen letters, cijfers en onderstrepingstekens bevatten.
• Een C ++ - variabelenaam mag niet beginnen met een getal.
• Variabelenamen mogen niet beginnen met een hoofdletter.
• Een variabelenaam die in C ++ wordt gebruikt, mag geen trefwoord zijn. Int is bijvoorbeeld een trefwoord dat wordt gebruikt om gehele getallen aan te duiden.
• De naam van een C ++ -variabele kan beginnen met een onderstrepingsteken. Het wordt echter niet als een goede praktijk beschouwd.

C ++ Variabele gegevenstypen

C ++ definieert een hele reeks primitieve typen

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

De rekenkundige typen omvatten tekens, gehele getallen, Booleaanse waarden en getallen met drijvende komma. Rekenkundig type indien verder onderverdeeld in 2 categorieën

1. Floating-point-typen . Het zwevende (of zwevende type) staat voor decimale getallen. De IEEE-standaard specificeert een minimumaantal significante cijfers. De meeste compilers bieden meestal meer precisie dan het gespecificeerde minimum. Doorgaans worden drijvers weergegeven in 32 bits, dubbele in 64 bits en lange dubbele in 96 of 128 bits.
2. Integrale typen (waaronder tekens, gehele getallen en Booleaanse typen). Het Booleaanse type heeft slechts twee soorten waarden: True of False. Er zijn verschillende soorten tekens , waarvan de meeste bestaan ​​om internationalisering te ondersteunen. Het meest basale karaktertype is char. Een teken heeft dezelfde grootte als een enkele machine-byte, wat een enkele byte betekent.

De integrale typen kunnen al dan niet ondertekend zijn.

Ondertekend type : ze vertegenwoordigen negatieve of positieve getallen (inclusief nul). In een ondertekend type moet het bereik gelijkmatig worden verdeeld tussen + ve en -ve waarden. Een 8-bits teken met teken bevat dus waarden van -127 tot 127.

Unsigned Type : In een unsigned type zijn alle waarden> = 0. Een 8-bit unsigned char kan 0 tot 255 bevatten (beide inclusief).

Variabelenaam of ID's

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

Identificatoren 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 enkele namen gereserveerd voor het gebruik ervan.

Er zijn veel geaccepteerde conventies voor het benoemen van variabelen in verschillende programmeertalen. Het volgen van deze conventies kan de leesbaarheid van het programma verbeteren.

• Een identifier moet op zijn minst een indicatie geven van de betekenis ervan.
• Variabelenamen zijn meestal 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 in de scope waarin deze is gedefinieerd. Voorbeeld:

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

int a,b;a=b=1000;

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

Const Qualifier in C ++

Stel dat er een variabele buffsize is die aangeeft hoeveel invoer van de gebruiker moet worden afgenomen. Hier willen we de waarde van buffsize niet gedurende het programma wijzigen. 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 genereert de compiler een fout.

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

Bereik van variabelen in C ++

Een scope is een span 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 de scope waarin hun declaratie verschijnt.

#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 <
Dit programma definieert 3 namen, namelijk, hoofd, som en val. Het gebruikt de naamruimtenaam std, samen met twee andere namen uit die naamruimte-cout en endl.

De functienaam "main" wordt gedefinieerd buiten de accolades. De functienaam heeft, net als de meeste andere namen die buiten een functie zijn gedefinieerd, een globaal bereik. Wat betekent dat, eenmaal gedeclareerd, namen met een globaal bereik toegankelijk zijn in het hele programma.
De variabele som wordt gedefinieerd binnen de reikwijdte van het blok dat het lichaam van de hoofdfunctie is. Het is toegankelijk vanaf het punt van aangifte en in de rest van de hoofdfunctie. Maar niet daarbuiten. Dit betekent dat variabel bedrag heeft block scope .
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 een lokale reikwijdte .

Genest bereik
Het bereik kan andere bereiken bevatten. Het ingesloten (of geneste) bereik wordt een binnenbereik genoemd. De bevattende scope is de buitenste scope.
#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;}
Uitgang # 1 verschijnt vóór de lokale definitie van hergebruikt. Dus deze output
statement is degene die de hergebruikte naam gebruikt die is gedefinieerd in het globale bereik. Deze verklaring wordt uitgevoerd
42 0
Uitgang # 2 vindt plaats na de lokale definitie van hergebruikt. Het is nu binnen bereik. Daarom gebruikt deze tweede outputinstructie eenvoudigweg het lokale object met de naam hergebruikt in plaats van het globale object en outputs
0 0
Uitgang 3 overschrijft de standaardbereikregels met behulp van de bereikoperator. Het globale bereik heeft geen naam. Dus als de scope-operator (: :) een lege linkerkant heeft. Het interpreteert het als een verzoek om de naam aan de rechterkant van het globale bereik op te halen. De uitdrukking gebruikt dus de globale hergebruikt en outputs
42 0

Conversie van variabele typen
Een variabele van het ene type kan worden omgezet in een ander. Het staat bekend als "Type Conversion." Laten we eens kijken naar de regels voor het converteren van verschillende typen C ++ - variabelen:
Het toewijzen van non-bool aan een bool-variabele levert false op als de waarde 0 is en anders true.
bool b = 42; // b is true
Het toekennen 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 drijvende-kommawaarde aan een variabele van het type int levert de waarde op die wordt afgekapt. De waarde die wordt opgeslagen is het deel voor de komma.
int i = 3.14; // i has value 3
Het toekennen van een int-waarde aan een variabele van het type float 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 verwerken.
Int i=3;double pi = i; // pi has value 3.0
Als we proberen een waarde buiten bereik toe te wijzen aan een variabele van het niet-ondertekende type, is het resultaat de rest van de waarde% (modulo)
Een 8-bits niet-ondertekend char-type kan bijvoorbeeld waarden bevatten van 0 tot en met 255. 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-bit niet-ondertekend teken, door de bovenstaande logica, dat object de waarde 255.
unsigned char c = -1; // assuming 8-bit chars, c has value 255
Als we proberen een waarde toe te kennen die buiten het bereik valt aan een object van een ondertekend type, is het resultaat onvoorspelbaar. Het is niet gedefinieerd. Het programma kan aan de buitenkant lijken te werken, of het kan crashen, of het kan garbage-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 truei = 0;
Als deze waarde = 0, dan is de voorwaarde onwaar; alle andere (niet-nul) waarden leveren true op. Volgens hetzelfde concept, wanneer we een bool gebruiken in een rekenkundige uitdrukking, wordt de waarde ervan altijd geconverteerd naar 0 of 1. Als resultaat is het gebruik van een bool in een rekenkundige uitdrukking meestal vrijwel zeker onjuist.
Let op: Combineer geen ondertekende en niet-ondertekende typen
Expressies die ondertekend en niet-ondertekend combineren, kunnen verrassende en verkeerde resultaten opleveren als de waarde met teken negatief is. Zoals hierboven besproken, worden ondertekende waarden automatisch geconverteerd naar niet-ondertekende.
Bijvoorbeeld in een rekenkundige uitdrukking zoals
x* y
Als x -1 is en y 1, en als x en y allebei int zijn, dan is de waarde, zoals verwacht, -1.
Als x int is en y niet ondertekend is, dan 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.

Registreer variabelen
Registersvariabelen zijn sneller toegankelijk in vergelijking met geheugenvariabelen. Variabelen die vaak in een C ++ -programma worden gebruikt, kunnen dus in registers worden geplaatst met het trefwoord register . Het register sleutelwoord vertelt de compiler om de gegeven variabele in een register op te slaan. Het is de keuze van de compiler om het in een register te plaatsen of niet. Over het algemeen voeren compilers zelf verschillende optimalisaties uit, waaronder het opnemen van enkele variabelen in het register. Er is geen limiet aan het aantal registervariabelen in een C ++ -programma. Maar de compiler slaat de variabele mogelijk niet op in een register. Dit komt doordat het registergeheugen erg beperkt is en meestal wordt gebruikt door het besturingssysteem.
Definiëren:
register int i;
Opmerkingen
Opmerkingen zijn de delen van de code die door de compiler worden genegeerd. Hiermee kan de programmeur aantekeningen maken in de relevante delen van de broncode / het programma. Opmerkingen komen in blokvorm of in enkele regels. De opmerkingen van het programma zijn verklarende verklaringen. Het kan worden opgenomen in de C ++ -code die iedereen helpt bij het lezen van de broncode. Alle programmeertalen laten enige vorm van commentaar toe. C ++ ondersteunt zowel opmerkingen met één regel als met meerdere regels.

Opmerkingen van één regel zijn de opmerkingen 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.
Opmerkingen met meerdere regels zijn de opmerkingen die beginnen met / * en eindigen met * /.

/* This is a comment *//* C++ comments can also* span multiple lines*/
 
Escape-reeksen
Sommige tekens, zoals backspace- en controletekens, hebben geen zichtbare afbeelding. Dergelijke 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 geen van deze tekens rechtstreeks gebruiken. In plaats daarvan kunnen we een escape-reeks gebruiken om zo'n teken weer te geven. Een ontsnappingsreeks begint met een backslash.
De programmeertaal C ++ definieert verschillende escape-reeksen:
 

 
 

Wat doet het?
 

Karakter
 

 
 

Nieuwe lijn
 

\ n
 

 
 

Verticaal tabblad
 

\ v
 

 
 

Backslash
 

​
 

 
 

Vervoer terug
 

\ r
 

 
 

Horizontaal tabblad
 

\ t
 

 
 

Backspace
 

\ b
 

 
 

Vraagteken
 

​
 

 
 

Formfeed
 

\ f
 

 
 

Alert (bel)
 

\een
 

 
 

Dubbele aanhalingstekens
 

​
 

 
 

Alleenstaande citaat
 

​
 

 

 

We gebruiken een escape-reeks alsof het een enkel teken is:
cout << '\n'; // prints a newlinecout << "\tguru99!\n"; // prints a tab followed by "guru99!" and a newline
We kunnen ook gegeneraliseerde escape-reeksen \ x schrijven, gevolgd door een of meer hexadecimale cijfers. Of we gebruiken een \ gevolgd door een of twee of drie octale cijfers. De gegeneraliseerde escape-reeks vertegenwoordigt de numerieke waarde van het teken. Enkele voorbeelden (uitgaande van de tekenset Latin-1):
\7 (bell) \12 (newline) \40 (blank)\0 (null) \115 ('M') \x4d ('M')
We kunnen vooraf gedefinieerde escape-reeksen gebruiken, zoals we elk ander teken gebruiken.
cout << "Hi \x4dO\115!\n"; // prints Hi MOM! followed by a newlinecout << '\115' << '\n'; // prints M followed by a newline
Overzicht

Een C ++ -variabele geeft ons een benoemde opslagcapaciteit.
C ++ variabeletypen: int, double, char, float, string, bool, etc.
Het ingesloten (of geneste) bereik wordt een binnenbereik genoemd en het bevattende bereik is het buitenbereik.
Een variabele van het ene type kan worden omgezet in een ander. Het staat bekend als "Type Conversion."
Registersvariabelen zijn sneller toegankelijk in vergelijking 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.