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

Variabelen in C++

Een C++-variabele biedt ons een benoemde opslagmogelijkheid. Het stelt de programmeur in staat om gegevens te 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 geheugenkaart van de variabele, het waardenbereik 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
• Variabele naam of ID's
• Const-kwalificatie in C++
• Omvang van variabelen in C++
• Conversie van variabel type
• Register variabelen
• Escape-reeksen

Basistypen variabelen in C++

Dit zijn de basistypen van C++-variabelen:

Int:

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

Dubbel:

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

Char:

Een letterlijke letter wordt gemaakt door een enkel teken tussen enkele aanhalingstekens te plaatsen. Bijvoorbeeld:‘a’, ‘m’, ‘F’, ‘P’, ‘}’ etc.

Zweven:

Een letterlijke met drijvende komma is een numerieke letterlijke die ofwel een fractionele vorm 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 met je?"

Bool:

Het bevat de Booleaanse waarde waar of onwaar.

Regels voor het declareren van variabelen in C++

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

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

C++ variabele gegevenstypen

C++ definieert een hele reeks primitieve typen

De leegte type heeft geen bijbehorende waarden en kan in slechts enkele gevallen worden gebruikt. Het is meestal 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. Drijvende-kommatypes . De float (of het zwevende type) vertegenwoordigen decimale getallen. De IEEE-standaard specificeert een minimum aantal significante cijfers. De meeste compilers bieden meestal meer precisie dan het gespecificeerde minimum. Meestal worden floats weergegeven in 32 bits, doubles in 64 bits en long doubles in 96 of 128 bits.
2. Integrale typen (waaronder tekens, gehele getallen en Booleaanse typen). De Boolean type heeft slechts twee soorten waarden:True of False. Er zijn verschillende char soorten, waarvan de meeste bestaan ​​om internationalisering te ondersteunen. Het meest elementaire karaktertype is char. Een char is even groot als een enkele machinebyte, wat een enkele byte betekent.

De Integrale typen kan worden ondertekend of niet ondertekend.

Ondertekend type :Ze vertegenwoordigen negatieve of positieve getallen (inclusief nul). In een ondertekend type moet het bereik gelijkelijk worden verdeeld tussen +ve en -ve waarden. Dus een 8-bit ondertekend char zal waarden bevatten van –127 tot 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).

Variabele naam of ID's

Identificatiecodes kunnen bestaan ​​uit enkele letters, cijfers en het onderstrepingsteken of een combinatie daarvan. Er wordt geen limiet gesteld aan de lengte van de naam.

ID's moeten

• begin 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 gebruik.

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 enige 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 niet guru99website.

C++ variabele verklaring en definitie

Een declaratie van een variabele maakt een naam bekend aan het programma in 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 inputs aangeeft dat van de gebruiker moet worden genomen. Hier willen we de waarde van buffsize in 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 verklaard en geïnitialiseerd. Anders genereert 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 

Omvang van variabelen in C++

Een scope is een spanwijdte van een programma waarin een variabele een betekenis heeft. Meestal kan dezelfde naam worden gebruikt om naar verschillende entiteiten binnen verschillende scopes te verwijzen. Variabelen zijn zichtbaar vanaf het punt waar 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, 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 main, zoals de meeste andere namen die buiten een functie zijn gedefinieerd, heeft een globaal bereik. Wat betekent dat, eenmaal gedeclareerd, namen die binnen het globale bereik . vallen zijn gedurende het hele programma toegankelijk.
• De variabele som wordt gedefinieerd binnen het bereik van het blok dat het hoofdgedeelte van de hoofdfunctie is. Het is toegankelijk vanaf het declaratiepunt en in de rest van het hoofdgedeelte van de hoofdfunctie. Daarbuiten echter niet. Dit betekent dat de variabele som een ​​blokbereik heeft .
• De variabele val wordt gedefinieerd in het bereik van "for statement". Het kan gemakkelijk in die instructie worden gebruikt, maar niet elders in de hoofdfunctie. Het heeft lokale reikwijdte .

Genest bereik

Het bereik kan andere bereiken bevatten. De ingesloten (of geneste) scope wordt een inner scope genoemd. De bevattende scope is de buitenste scope.

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

Uitvoer #1 verschijnt vóór de lokale definitie van hergebruikt. Dus deze output

statement is degene die de naam hergebruikt gebruikt die is gedefinieerd in het globale bereik. Deze verklaring geeft

42 0

Uitvoer #2 vindt plaats na de lokale definitie van hergebruikt. Het is nu binnen bereik. Daarom gebruikt deze tweede uitvoerinstructie eenvoudig het lokale object met de naam hergebruikt in plaats van globale en voert uit

0 0

Uitvoer #3 overschrijft de standaardbereikregels met behulp van de bereikoperator. De globale scope heeft geen naam. Dus wanneer de scope-operator (::) een lege linkerkant heeft. Het interpreteert het als een verzoek om de naam aan de rechterkant van de globale scope op te halen. De uitdrukking gebruikt dus de globale hergebruikte en outputs

42 0

Conversie van variabel type

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

Het toewijzen van niet-bool aan een bool-variabele levert false op als de waarde 0 is en anders waar.

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 drijvende-kommawaarde 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 toewijzen van een int-waarde aan een variabele van het type float resulteert erin dat het fractionele deel nul wordt. Precisie gaat meestal verloren als het gehele getal meer bits heeft dan de zwevende variabele kan accommoderen.

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

Als we een waarde buiten het bereik proberen toe te wijzen 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 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, door de bovenstaande logica, geeft de toewijzing van –1 aan een 8-bits teken zonder teken dat object 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 kennen aan een object met een ondertekend type, is het resultaat onvoorspelbaar. Het is ongedefinieerd. Het programma kan aan de buitenkant lijken te werken, of het kan crashen, of het kan waardes produceren.

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

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

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

Als deze waarde =0, is de voorwaarde onwaar; alle andere (niet-nul) waarden leveren true op. Volgens hetzelfde concept, wanneer we een bool in een rekenkundige uitdrukking gebruiken, wordt 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:meng geen ondertekende en niet-ondertekende typen

Expressies 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 als

x* y

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

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

Registreer variabelen

Registervariabelen zijn sneller toegankelijk in vergelijking met geheugenvariabelen. Variabelen die vaak in een C++-programma worden gebruikt, kunnen dus in registers worden gezet met behulp van register trefwoord. Het register sleutelwoord vertelt de compiler om de gegeven variabele op te slaan in een register. 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 plaatsen van enkele variabelen in het register. Er is geen limiet op het aantal registervariabelen in een C++-programma. Maar de compiler mag de variabele niet opslaan in een register. Dit komt omdat het registergeheugen erg beperkt is en het meest wordt gebruikt door het besturingssysteem.

Om te 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 programmacommentaar is een toelichting. Het kan worden opgenomen in de C++-code die iedereen helpt de broncode te lezen. Alle programmeertalen staan ​​enige vorm van commentaar toe. C++ ondersteunt zowel enkelregelige als meerregelige opmerkingen.

• Reacties 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.
• Opmerkingen met meerdere regels zijn degenen 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 ontsnappingsreeks gebruiken om zo'n char weer te geven. Een escape-reeks begint met een backslash.

De programmeertaal C++ definieert verschillende escape-reeksen:

Wat doet het? Karakter

Nieuwe regel

\n

Verticaal tabblad

\v

Backslash

\\

Koets retour

\r

Horizontaal tabblad

\t

Backspace

\b

Vraagteken

\?

Formfeed

\f

Alarm (bel)

\a

Dubbel aanhalingsteken

\”

Enkele quote

\'

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

cout << '\n';        // prints a newline
cout << "\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 algemene 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 escape-reeksen gebruiken, 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

• Een C++-variabele biedt ons een opslagmogelijkheid met een naam.
• Typen C++-variabelen: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 'Typeconversie'.
• Registervariabelen zijn sneller toegankelijk dan geheugenvariabelen.
• Opmerkingen zijn de delen van de code die door de compiler worden genegeerd.
• Sommige tekens, zoals backspace- en controletekens, hebben geen zichtbare afbeelding.