C++ Variabelen en Datatypes: Expert‑handleiding voor int, double, char, string, bool

Variabelen in C++

In C++ is een variabele een benoemde opslaglocatie waarmee een programmeerder data kan bewaren en manipuleren. Elke variabele heeft een expliciet type dat het geheugengebruik, het toegestane waardenbereik en de mogelijke bewerkingen bepaalt.

Deze tutorial behandelt:

• Variabelen in C++
• Basistypen variabelen
• Declaratieregels
• Datatype‑hiërarchie
• Identificatoren en naamgevingsconventies
• Const‑kwalificator
• Scope‑regels
• Impliciete en expliciete type‑conversie
• Register‑variabelen
• Commentaren en escape‑sequences

Basistypen van Variabelen in C++

int – Hele getallen zonder breuk‑ of exponentdeel (bijv. 120, -90).

double – Dubbele‑precisie drijvende‑kommagetallen (bijv. 11.22, 2.345).

char – Enkele karakterliterals tussen enkele aanhalingstekens (bijv. 'a', 'm', 'F', 'P', '}').

float – Enkele‑precisie drijvende‑kommawaarden (bijv. 1.3, 2.6).

string – Tekenreeks tussen dubbele aanhalingstekens (bijv. "Hoe gaat het?").

bool – Bevat true of false.

Regels voor het Declareren van Variabelen in C++

• Namen mogen letters, cijfers en underscores bevatten.
• Ze mogen niet beginnen met een cijfer.
• Conventionele praktijk kiest voor kleine letters; hoofdletters duiden meestal op constanten.
• Namen mogen niet botsen met taal‑keywords (bijv. int).
• Starten met een underscore is toegestaan maar wordt afgeraden vanwege gereserveerde identificatoren.

C++ Variabele Datatypes

C++ biedt een rijke set primitieve typen. Het void-type heeft geen waarde en wordt typisch gebruikt als retourtype van een functie wanneer niets wordt teruggegeven.

Rekentypen vallen in twee categorieën:

1. Drijvende‑kommatypes: float (≈32 bits), double (≈64 bits), en long double (≈96/128 bits afhankelijk van implementatie).
2. Integraal types: integers, karakters, en bool. Integraal types kunnen gesigned of unsigned zijn.

Gesigned types vertegenwoordigen negatieve, nul, en positieve waarden. Bijvoorbeeld, een 8‑bit gesigned char loopt van –127 tot 127.

Unsigned types bevatten alleen niet‑negatieve waarden. Een 8‑bit unsigned char loopt van 0 tot 255.

Variabelenamen of Identificatoren

Identificatoren mogen letters, cijfers en underscores bevatten. De lengte is onbeperkt, en ze zijn hoofdlettergevoelig:

int guru99, gurU99, GuRu99, GURU99;

Gereserveerde keywords mogen niet hergebruikt worden als identificatoren. Het aanhouden van duidelijke naamgevingsconventies verbetert de leesbaarheid: gebruik kleine letters voor variabelen, camelCase of snake_case voor samengestelde namen, en hoofdletters voor klassenamen.

Declaratie- en Definitievoorbeelden

int a = 5; int b; char c = 'A'; int a, b; a = b = 1000; int a(5); int b{5};

Const‑kwalificator in C++

Gebruik const wanneer een waarde ongewijzigd moet blijven na initialisatie:

const int bufSize = 512; // invoerbuffergrootte

Een const-variabele moet geïnitialiseerd worden; anders geeft de compiler een fout.

const int i = get_size(); // OK: runtime‑init
const int j = 42;         // OK: compile‑time init
const int k;              // fout: niet‑geïnitialiseerde const
const int i = 42;
const int ci = i;         // OK: kopie van i

Scope van Variabelen in C++

Scope definieert waar een naam zichtbaar is. Variabelen zijn toegankelijk vanaf hun declaratiepunt tot het einde van de omringende blok.

#include <iostream>
int main() {
    int sum = 0;
    for (int val = 1; val <= 10; ++val)
        sum += val;
    std::cout << "Som van 1 tot 10 inclusief is " << sum << std::endl;
    return 0;
}

• main heeft globale scope.
• sum heeft blok‑scope binnen main.
• val heeft lokale scope binnen de for-lus.

Geneste Scope

#include <iostream>
using namespace std;
int reused = 42; // globale scope
int main() {
    int unique = 0; // blok‑scope
    cout << reused << " " << unique << endl; // 42 0
    int reused = 0; // lokale hergebruik verbergt globale
    cout << reused << " " << unique << endl; // 0 0
    cout << ::reused << " " << unique << endl; // 42 0
    return 0;
}

Variabele Type‑Conversie

C++ voert impliciete conversies uit onder bepaalde voorwaarden. Belangrijke regels zijn:

• Niet‑bool naar bool: 0 wordt false; elke andere waarde wordt true.

  bool b = 42; // b is true

• bool naar rekenkundig: true wordt 1, false wordt 0.

  bool b = true; int i = b; // i is 1

• Drijvende‑komma naar integer: afkapting naar nul toe.

  int i = 3.14; // i is 3

• Integer naar drijvende‑komma: breukgedeelte gaat verloren.

  int i = 3; double pi = i; // pi is 3.0

• Unsigned overflow: waarde wrapt modulo basis.

  unsigned char c = -1; // 255 op 8‑bit chars

• Signed overflow: ongedefinieerd gedrag.

Bij het mengen van gesigned en unsigned integers kunnen negatieve gesigned waarden onverwacht converteren naar grote unsigned waarden.

Register‑Variabelen

Gebruik het register-keyword om aan te geven dat een frequent benaderde variabele in een CPU‑register moet worden opgeslagen. Moderne compilers negeren de hint meestal en voeren hun eigen optimalisaties uit.

register int i;

Commentaren

Commentaren worden door de compiler genegeerd en dienen om code te documenteren:

• Enkelvoudige regel – begint met //.
• Meerdere regels – begrensd door /* ... */.

/* Dit is een commentaar */
/* C++ commentaren kunnen ook meerdere regels beslaan */

Escape‑Sequences

Escape‑sequences vertegenwoordigen niet‑printbare of speciale karakters:

cout << '\n'; // nieuwe regel
cout << "\tguru99!\n"; // tab + tekst + nieuwe regel

Gegeneraliseerde sequences gebruiken hexadecimale of octale waarden:

\7  // bel
\12 // nieuwe regel
\40 // spatie
\x4D // 'M'

Samenvatting

• Variabelen bieden benoemde opslag en zijn getypeerd.
• Primaire typen: int, double, char, float, string, bool.
• Scope definieert zichtbaarheid; geneste scopes kunnen namen overschaduwen.
• Impliciete en expliciete conversies bestaan, maar moeten voorzichtig gebruikt worden.
• Register‑hints kunnen prestaties verbeteren, maar zijn adviseurs.
• Commentaren en escape‑sequences helpen bij leesbaarheid en correcte output.