C++ Constanten & Literals Uitgelegd: Types, Syntax en Best Practices

Constanten verwijzen naar vaste waarden die het programma niet mag wijzigen en ze heten literals.

Constanten kunnen van elk van de basistypen zijn en kunnen worden verdeeld in Gehele Getallen, Drijvende-Komma Getallen, Karakters, Strings en Boolean Waarden.

Opnieuw, constanten worden behandeld net als gewone variabelen, behalve dat hun waarden niet gewijzigd kunnen worden na hun definitie.

Gehele Literals (Integer Literals)

Een integer literal kan een decimaal, octaal of hexadecimaal constant zijn. Een prefix specificeert de basis of radix: 0x of 0X voor hexadecimaal, 0 voor octaal, en niets voor decimaal.

Een integer literal kan ook een suffix hebben dat een combinatie is van U en L, voor unsigned en long respectievelijk. Het suffix kan hoofdletters of kleine letters zijn en in willekeurige volgorde.

Hier zijn enkele voorbeelden van integer literals:

 212 // Legaal
 215u // Legaal
 0xFeeL // Legaal
 078 // Illegal: 8 is geen octaal cijfer
 032UU // Illegal: kan geen suffix herhalen 

Hier volgen andere voorbeelden van verschillende typen integer literals:

 85 // decimaal
 0213 // octaal
 0x4b // hexadecimaal
 30 // int
 30u // unsigned int
 30l // long
 30ul // unsigned long 

Drijvende-Komma Literals (Floating-point Literals)

Een floating-point literal heeft een geheel deel, een decimaal punt, een fractioneel deel en een exponent deel. U kunt floating point literals representeren in decimale vorm of exponentiële vorm.

Bij representatie in decimale vorm moet u het decimaal punt, de exponent, of beide opnemen. Bij representatie in exponentiële vorm moet u het gehele deel, het fractionele deel, of beide opnemen. De gesigneerde exponent wordt geïntroduceerd door e of E.

Hier zijn enkele voorbeelden van floating-point literals:

 3.14159 // Legaal
 314159E-5L // Legaal
 510E // Illegal: onvolledige exponent
 210f // Illegal: geen decimaal of exponent
 .e55 // Illegal: ontbrekend geheel of fractioneel deel 

Boolean Literals

Er zijn twee Boolean literals en ze maken deel uit van de standaard C++ trefwoorden:

• Een waarde van true die true vertegenwoordigt.

• Een waarde van false die false vertegenwoordigt.

U zou de waarde van true niet gelijk moeten stellen aan 1 en de waarde van false niet gelijk aan 0.

Karakter Literals (Character Literals)

Karakter literals worden omsloten door enkele aanhalingstekens. Als het literal begint met L (alleen hoofdletter), is het een wide character literal (bijv., L'x') en moet het opgeslagen worden in wchar_t type variabele. Anders is het een narrow character literal (bijv., 'x') en kan het opgeslagen worden in een simpele variabele van char type.

Een karakter literal kan een gewoon karakter zijn (bijv., 'x'), een escape sequence (bijv., '\t'), of een universeel karakter (bijv., '\u02C0').

Er zijn bepaalde karakters in C++ die, wanneer ze voorafgegaan worden door een backslash, een speciale betekenis hebben en gebruikt worden om dingen te representeren zoals newline (\n) of tab (\t). Hier is een lijst van enkele dergelijke escape sequence codes:

Hier volgt een voorbeeld om enkele escape sequence karakters te tonen:

 #include <iostream>
using namespace std;
int main() {
  cout << "Hello\tWorld\n\n";
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

Hello World

String Literals

String literals worden omsloten door dubbele aanhalingstekens. Een string bevat karakters die vergelijkbaar zijn met karakter literals: gewone karakters, escape sequences, en universele karakters.

U kunt een lange regel in meerdere regels breken met string literals en ze scheiden met witruimtes.

Hier zijn enkele voorbeelden van string literals. Alle drie vormen zijn identieke strings.

 "hello, dear"
 "hello, \ dear"
 "hello, " "d" "ear" 

Constanten Definiëren

Er zijn twee eenvoudige manieren in C++ om constanten te definiëren:

• Met behulp van #define preprocessor.

• Met behulp van const trefwoord.

De #define Preprocessor

Hier is de vorm om #define preprocessor te gebruiken om een constante te definiëren:

 #define identifier value 

Het volgende voorbeeld verduidelijkt het in detail:

 #include <iostream>
using namespace std;
#define LENGTH 10
#define WIDTH 5
#define NEWLINE '\n'
int main() {
  int area;
  area = LENGTH * WIDTH;
  cout << area;
  cout << NEWLINE;
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

 50 

Het const Trefwoord

U kunt const prefix gebruiken om constanten te declareren met een specifiek type als volgt:

 const type variable = value; 

Het volgende voorbeeld verduidelijkt het in detail:

 #include <iostream>
using namespace std;
int main() {
  const int LENGTH = 10;
  const int WIDTH = 5;
  const char NEWLINE = '\n';
  int area;
  area = LENGTH * WIDTH;
  cout << area;
  cout << NEWLINE;
  return 0;
} 

Wanneer de bovenstaande code gecompileerd en uitgevoerd wordt, produceert het het volgende resultaat:

 50 

Let op dat het een goede programmeerpraktijk is om constanten in HOOFDLETTERS te definiëren.