Variabele van het type char in C. Gegevenstypen in C-taal. Variabele in computergeheugen

In deze sectie worden de belangrijkste gegevenstypen in C++ besproken; deze gegevenstypen worden ook wel ingebouwd genoemd. De programmeertaal C++ is een uitbreidbare programmeertaal. De term uitbreidbaar betekent dat u naast de ingebouwde gegevenstypen uw eigen gegevenstypen kunt maken. Daarom zijn er een groot aantal gegevenstypen in C++. We zullen alleen de belangrijkste bestuderen.

Tabel 1 - C++-gegevenstypen
Type byte Bereik van geaccepteerde waarden

gegevenstype geheel getal (Boolean).
bool 1 0 / 255

gegevenstype geheel getal (teken).
verkoold 1 0 / 255

gehele gegevenstypen
korte int 2 -32 768 / 32 767
niet-ondertekende korte int 2 0 / 65 535
int 4
niet ondertekend int 4 0 / 4 294 967 295
lang int 4 -2 147 483 648 / 2 147 483 647
niet-ondertekend lange int 4 0 / 4 294 967 295

gegevenstypen met drijvende komma
vlot 4 -2 147 483 648.0 / 2 147 483 647.0
lange vlotter 8
dubbele 8 -9 223 372 036 854 775 808 .0 / 9 223 372 036 854 775 807.0

Tabel 1 toont de belangrijkste gegevenstypen in C++. De gehele tabel is verdeeld in drie kolommen. De eerste kolom geeft aan gereserveerd woord, die ieder zijn eigen gegevenstype bepalen. De tweede kolom geeft het aantal bytes aan dat is toegewezen aan een variabele met het bijbehorende gegevenstype. De derde kolom toont het bereik aanvaardbare waarden. Houd er rekening mee dat in de tabel alle gegevenstypen zijn gerangschikt van klein naar groot.

bool-gegevenstype

De eerste in de tabel is het bool-gegevenstype — een gegevenstype met gehele getallen, aangezien het bereik van geldige waarden gehele getallen van 0 tot 255 is. Maar zoals je al hebt opgemerkt, staat er tussen haakjes het gegevenstype Booleaans, en dit is ook waar. Omdat bool uitsluitend gebruikt om de resultaten van Booleaanse expressies op te slaan. Een Booleaanse expressie kan twee resultaten opleveren: waar of onwaar. waar - als logische uitdrukking waar, onwaar - als de logische expressie onwaar is.

Maar aangezien het bereik van geldige waarden van het bool-gegevenstype van 0 tot 255 ligt, was het nodig om dit bereik op de een of andere manier te matchen met de logische constanten waar en onwaar gedefinieerd in de programmeertaal. De constante true is dus equivalent aan alle getallen van 1 tot en met 255, terwijl de constante false equivalent is aan slechts één geheel getal - 0. Beschouw een programma dat het gegevenstype bool gebruikt.

// data_type.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include naamruimte std gebruiken; int main(int argc, char* argv) ( bool boolean = 25; // type variabele bool met naam boolean if (boolean) // voorwaarde van de if-instructie cout<< "true = " << boolean << endl; // выполнится в случае истинности условия else cout << "false = " << boolean << endl; // выполнится в случае, если условие ложно system("pause"); return 0; }

IN lijn 9typevariabele gedeclareerd bool , die is geïnitialiseerd op 25. Theoretisch daarnalijnen 9, in een Booleaanse variabele zou het getal 25 moeten bevatten, maar in feite bevat deze variabele het getal 1. Zoals ik al zei, het getal 0 is een valse waarde, het getal 1 is een echte waarde. Het punt is dat in een variabele als bool kan twee waarden bevatten: 0 (onwaar) of 1 (waar). Terwijl onder het gegevenstype bool er wordt een hele byte toegewezen, wat betekent dat er een variabele van het type is bool kan getallen van 0 tot 255 bevatten. Om valse en echte waarden te bepalen zijn slechts twee waarden 0 en 1 nodig. De vraag rijst: “Waar zijn de andere 253 waarden voor?”

Op basis van deze situatie hebben we afgesproken om de getallen 2 tot en met 255 te gebruiken als het equivalent van het getal 1, dat wil zeggen de waarheid. Dit is precies de reden waarom de Booleaanse variabele het getal 25 bevat en niet 1. In lijnen 10 -13 gedeclareerd, waardoor de controle wordt overgedragen aan de exploitant lijn 11, als de voorwaarde waar is, en de operator in lijn 13, als de voorwaarde onwaar is. Het resultaat van het programma wordt weergegeven in Figuur 1.

Waar = 1 Druk op een willekeurige toets om door te gaan. . .

Figuur 1 - bool-gegevenstype

Gegevenstype char

Het char-gegevenstype is een geheel getal-gegevenstype dat wordt gebruikt om tekens weer te geven. Dat wil zeggen, elk teken komt overeen met een bepaald getal uit het bereik. Het gegevenstype char wordt ook wel het tekengegevenstype genoemd, omdat de grafische weergave van tekens in C++ mogelijk is dankzij char. Om tekens in C++ weer te geven, wordt aan het char-gegevenstype één byte toegewezen, één byte bevat 8 bits, vervolgens verheffen we twee tot de macht 8 en krijgen de waarde 256 - het aantal tekens dat kan worden gecodeerd. Met het char-gegevenstype kunt u dus elk van de 256 tekens weergeven. Alle gecodeerde tekens worden weergegeven in .

ASCII (van Engelse standaardcode voor informatie-uitwisseling) - Amerikaanse standaardcode voor informatie-uitwisseling.

Overweeg een programma dat het gegevenstype char gebruikt.

//symbols.cpp: Definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include naamruimte std gebruiken; int main(int argc, char* argv) ( char symbool = "a"; // variabele declaratie typ char en initialiseren met het symbool "a" cout<< "symbol = " << symbol << endl; // печать символа, содержащегося в переменной symbol char string = "сайт"; // объявление символьного массива (строки) cout << "string = " << string << endl; // печать строки system("pause"); return 0; }

Dus, binnen lijn 9een variabele genaamd symbool , krijgt deze de symboolwaarde toegewezen"A" ( ASCII-code). IN lijn 10 cout-operator drukt het teken af ​​dat in de variabele zit symbool IN lijn 11een stringarray met de naam snaar , en de grootte van de array wordt impliciet gespecificeerd. Een string wordt opgeslagen in een stringarray"website" . Houd er rekening mee dat toen we het symbool opsloegen in een variabele zoals verkoold , daarna plaatsen we na het gelijkteken enkele aanhalingstekens waarin we het symbool schreven. Bij het initialiseren van een stringarray met een bepaalde string worden dubbele aanhalingstekens geplaatst na het gelijkteken, waarin een bepaalde string wordt geschreven. Net als bij een normaal teken worden tekenreeksen uitgevoerd met behulp van de operator uit, lijn 12. Het resultaat van het programma wordt getoond in Figuur 2.

Symbool = een string = site Druk op een willekeurige toets om door te gaan. . .

Figuur 2 - char-gegevenstype

Gehele gegevenstypen

Gegevenstypen met gehele getallen worden gebruikt om getallen weer te geven. Er zijn er zes in Tabel 1: korte int, niet-ondertekende korte int, int, niet-ondertekende int, lange int, niet-ondertekende lange int . Ze hebben allemaal hun eigen geheugengrootte en bereik van geaccepteerde waarden. Afhankelijk van de compiler kan de grootte van het in beslag genomen geheugen en het bereik van geaccepteerde waarden variëren. In Tabel 1 worden alle bereiken van geaccepteerde waarden en groottes van bezet geheugen gebruikt voor de MVS2010-compiler. Bovendien zijn alle gegevenstypen in Tabel 1 gerangschikt in oplopende volgorde van de grootte van het bezette geheugen en het bereik van geaccepteerde waarden. Het bereik van geaccepteerde waarden hangt op de een of andere manier af van de grootte van het bezette geheugen. Dienovereenkomstig geldt: hoe groter de omvang van het bezette geheugen, hoe groter het bereik van geaccepteerde waarden. Ook verandert het bereik van geaccepteerde waarden als het gegevenstype wordt gedeclareerd met het niet-ondertekende voorvoegsel. Het niet-ondertekende voorvoegsel betekent dat het gegevenstype geen ondertekende waarden kan opslaan, waarna het bereik van positieve waarden wordt verdubbeld, bijvoorbeeld de gegevenstypen short int en unsigned short int.

Voorvoegsels voor gegevenstypes van gehele getallen:

kort — het voorvoegsel verkort het gegevenstype waarop het wordt toegepast door de grootte van het geheugen dat het in beslag neemt te verkleinen;

lang — het voorvoegsel breidt het gegevenstype uit waarop het wordt toegepast door de omvang van het geheugen dat het in beslag neemt te vergroten;

unsigned: het voorvoegsel verdubbelt het bereik van positieve waarden, terwijl het bereik van negatieve waarden niet kan worden opgeslagen in dit gegevenstype.

In wezen hebben we dus één geheel getaltype dat gehele getallen vertegenwoordigt: het gegevenstype int. Dankzij de voorvoegsels kort, lang, niet-ondertekend verschijnt er een bepaalde verscheidenheid aan int-gegevenstypen, die verschillen in de grootte van het in beslag genomen geheugen en (of) het bereik van geaccepteerde waarden.

Gegevenstypen met drijvende komma

Er zijn twee soorten drijvende-kommagegevens in C++: float en double. Gegevenstypen met drijvende komma zijn ontworpen om getallen met drijvende komma op te slaan. De gegevenstypen float en double kunnen zowel positieve als negatieve getallen met drijvende komma opslaan. Het float-datatype heeft een geheugenvoetafdruk die de helft is van die van het double-datatype, waardoor het bereik van geaccepteerde waarden ook kleiner is. Als het float-gegevenstype wordt gedeclareerd met het lange voorvoegsel, is het bereik van geaccepteerde waarden gelijk aan het bereik van geaccepteerde waarden van het dubbele gegevenstype. Kortom, drijvende-kommagegevenstypen zijn nodig om problemen met zeer nauwkeurige berekeningen op te lossen, bijvoorbeeld geldtransacties.

We hebben dus gekeken naar de belangrijkste punten met betrekking tot de belangrijkste gegevenstypen in C++. Het enige dat overblijft is om te laten zien waar al deze bereiken van geaccepteerde waarden en de omvang van het bezette geheugen vandaan komen. En hiervoor zullen we een programma ontwikkelen dat de belangrijkste kenmerken van alle hierboven besproken soorten gegevens berekent.

// data_types.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include // I/O-manipulatiebibliotheek #include // headerbestand met wiskundige functies #include naamruimte std gebruiken; int main(int argc, char* argv) ( cout<< " data type " << "byte" << " " << " max value "<< endl // kolomkoppen <<"bool = " << sizeof(bool) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных bool*/ << (pow(2,sizeof(bool) * 8.0) - 1) << endl << "char = " << sizeof(char) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных char*/ << (pow(2,sizeof(char) * 8.0) - 1) << endl << "short int = " << sizeof(short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных short int*/ << (pow(2,sizeof(short int) * 8.0 - 1) - 1) << endl << "unsigned short int = " << sizeof(unsigned short int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned short int*/ << (pow(2,sizeof(unsigned short int) * 8.0) - 1) << endl << "int = " << sizeof(int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных int*/ << (pow(2,sizeof(int) * 8.0 - 1) - 1) << endl << "unsigned int = " << sizeof(unsigned int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных unsigned int*/ << (pow(2,sizeof(unsigned int) * 8.0) - 1) << endl << "long int = " << sizeof(long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных long int*/ << (pow(2,sizeof(long int) * 8.0 - 1) - 1) << endl << "unsigned long int = " << sizeof(unsigned long int) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных undigned long int*/ << (pow(2,sizeof(unsigned long int) * 8.0) - 1) << endl << "float = " << sizeof(float) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных float*/ << (pow(2,sizeof(float) * 8.0 - 1) - 1) << endl << "double = " << sizeof(double) << " " << fixed << setprecision(2) /*вычисляем максимальное значение для типа данных double*/ << (pow(2,sizeof(double) * 8.0 - 1) - 1) << endl; system("pause"); return 0; }

Dit programma is geplaatst zodat u de kenmerken van gegevenstypen in uw systeem kunt bekijken. Het is niet nodig om de code te begrijpen, omdat het programma controle-instructies gebruikt waar u waarschijnlijk nog niet bekend mee bent. Voor een oppervlakkige kennismaking met de programmacode zal ik hieronder enkele punten toelichten. Exploitant groottevan() Berekent het aantal bytes dat is toegewezen aan een gegevenstype of variabele. Functie pow(x,y) verheft de betekenis x tot de macht y , deze functie is beschikbaar vanuit het headerbestand . vaste en setprecision()-manipulatoren beschikbaar vanuit het headerbestand . De eerste is opgelost , geeft waarden in vaste vorm door aan de uitvoerstroom. Manipulator setprecision(n) geeft n weer decimalen. De maximale waarde van een bepaald gegevenstype wordt berekend met behulp van de volgende formule:

Max_val_type = 2^(b * 8 - 1) - 1; // voor gegevenstypen met negatieve en positieve getallen // waarbij b het aantal bytes is dat in het geheugen is toegewezen voor een variabele met dit gegevenstype // vermenigvuldigen met 8, aangezien er 8 bits in één byte zitten // trek 1 af tussen haakjes, omdat de bereiknummers in tweeën moeten worden gedeeld voor positieve en negatieve waarden // trek aan het einde 1 af, omdat het bereik van getallen begint bij nul // gegevenstypen met het voorvoegsel unsigned max_val_type = 2^(b * 8) - 1; // alleen voor gegevenstypen met positieve getallen // de verklaringen voor de formule zijn vergelijkbaar, alleen de eenheid wordt niet van het haakje afgetrokken

Een voorbeeld van hoe het programma werkt kunt u zien in Figuur 3. De eerste kolom toont de belangrijkste gegevenstypen in C++, de tweede kolom toont de grootte van het geheugen dat voor elk gegevenstype is toegewezen, en de derde kolom toont de maximale waarde die de overeenkomstige gegevenstypes bevatten. gegevenstype kan bevatten. De minimumwaarde blijkt vergelijkbaar te zijn met het maximum. Voor gegevenstypen met het niet-ondertekende voorvoegsel is de minimumwaarde 0.

Gegevenstype byte maximale waarde bool = 1 255.00 char = 1 255.00 short int = 2 32767.00 unsigned short int = 2 65535.00 int = 4 2147483647.00 unsigned int = 4 4294967295.00 long int = 4 2147483647.0 0 niet-ondertekende lange int = 4 4294967295.00 float = 4 2147483647.00 dubbel = 8 9223372036854775808.00 Druk op een willekeurige toets om door te gaan. . .

Figuur 3 - C++-gegevenstypen

Als bijvoorbeeld aan een variabele van het type short int de waarde 33000 wordt toegewezen, zal het bitraster overlopen, aangezien de maximale waarde in een variabele van het type short int 32767 is. Dat wil zeggen dat er een andere waarde in een variabele wordt opgeslagen. van het type short int, zal deze hoogstwaarschijnlijk negatief zijn. Omdat we het gegevenstype int hebben besproken, is het de moeite waard om op te merken dat u het trefwoord int kunt weglaten en bijvoorbeeld gewoon kort kunt schrijven. De compiler interpreteert zo'n invoer als short int. Hetzelfde geldt voor de voorvoegsels die lang en niet ondertekend zijn. Bijvoorbeeld:

// afkorting voor gegevenstype int short a1; // hetzelfde als kort int lang a1; // hetzelfde als long int unsigned a1; // hetzelfde als unsigned int unsigned short a1; // hetzelfde als niet-ondertekende korte int

Tags: C++-gegevenstypen, auto, decltype, automatische type-inferentie

Gegevenstypen

Net als in C moeten variabelen in C++ een geldige naam hebben. Dat wil zeggen: bestaan ​​uit cijfers, letters en een onderstrepingsteken, mogen niet beginnen met een cijfer en mogen niet samenvallen met functiewoorden, waarvan er nu meer zijn

uitlijnen uitlijnen En en_eq
asm auto bijten bijter
bool pauze geval vangst
verkoold char16_t char32_t klas
complconstconstexprconst_cast
doorgaandecltypestandaardverwijderen
Doen dubbele dynamische_cast anders
opsommingexplicietexporterenextern
valsvlotvoorvriend
ga naaralsinlineint
langveranderlijknaamruimtenieuw
neebehalve niet niet_eq nulptr
exploitantofof_eqprivé
beschermdpubliekregisterherinterpreteer_cast
opbrengstkortondertekendgroottevan
statischstatische_beweringstatische_caststructureren
schakelaarsjabloonditdraad_lokaal
gooienWAARpogingtypedef
getypttypenaamunieniet ondertekend
gebruikenvirtueelleegtevluchtig
wchar_tterwijlxorxor_eq

Net als C is C++ een hoofdlettergevoelige taal.

Basisgegevenstypen

Basisgegevenstypen in C++ kunnen in verschillende groepen worden verdeeld

Tekentype. Variabelen van het ondertekende type kunnen worden gebruikt om één teken op te slaan. Het eenvoudigste type is char, dat 1 byte groot is. Er zijn ook typen die tekens groter dan één byte vertegenwoordigen

Eigenlijk bestaan ​​​​deze typen in C, we hebben niet in detail stilgestaan ​​bij het bestuderen van de weergave van snaren.

Gehele gegevenstypen. Net als in C kunnen ze ondertekende en niet-ondertekende modifiers hebben. Net als in C zijn de hoofdtypen char, int, long en long long. Hier is niets nieuws verschenen.

Drijvende-kommagetallen. Vertegenwoordigd door float-, dubbele en lange dubbele typen. Niets nieuws vergeleken met C.

Alle hierboven beschreven typen worden ook wel rekenkunde genoemd. Daarnaast is er ook een leeg type - void (ook niets nieuws vergeleken met C) en een null-pointer. Nu is er, in plaats van NULL met zijn verbazingwekkende eigenschappen, een nieuw fundamenteel type nullptr_t met een enkele waarde nullptr, die een nul-pointer opslaat en alleen gelijk is aan zichzelf. Tegelijkertijd kan het naar een nulwijzer van het gewenste type worden gecast.

Het Booleaanse type werd geïntroduceerd in C++. Er worden slechts twee mogelijke waarden opgeslagen: waar en onwaar.

C++ ondersteunt ook veel samengestelde gegevenstypen, die later zullen worden besproken.

Variabelen declareren en initialiseren

In C++ kunnen variabelen overal binnen een functie worden gedeclareerd, niet alleen aan het begin van een codeblok. Variabelen kunnen ook in een for-lus worden gedeclareerd.

Zweven een; vlotter b; zwevende som; vlotter stap; a = 3,0f; b = 4,3f; som = 0,0f; stap = 0,05f; voor (zweven i = a; i< b; i += step) { sum += i * i; } float mid = sum / (b - a) / step;

U kunt variabelen initialiseren tijdens het maken, zoals in C

Int x = 0;

of, met behulp van de constructor

Intx(0); dubbel d(3,2);

Bovendien is in C++ 2011 het zogenaamde uniforme initialisatie, een universele initialisatie waarmee u één syntaxis kunt gebruiken om objecten te initialiseren

Structuurpunt ( int x; int y; ); struct Puntpositie = ( 3, 4 ); Punt *pt = nieuw Punt(6, 8); int lengte(5);

Typ gevolgtrekking

In C++ 2011 wordt het servicewoord auto gebruikt om automatisch het type variabelen te bepalen. Vaak kan het type van een variabele worden bepaald op basis van de rechterkant van de initialisatie. In het geval dat de compiler het type ondubbelzinnig kan bepalen, kan dit worden gespecificeerd met behulp van het autofunctiewoord:

Automatisch x = 3; //equivalent aan int x = 3; automatisch punt = nieuw punt; //equivalent aan Punt *punt = nieuw Punt

Bovendien is het mogelijk om het type van een variabele in te stellen op basis van een bestaand type, met behulp van het servicewoord decltype

Int intX = 42; decltype(intX) intY = 33; //equivalent aan int intY = 33; auto pt1 = nieuw punt; decltype(pt1) p2 = nieuw punt(2, 6); //equivalent aan //Punt *pt1 = nieuw punt; //Punt *pt2 = nieuw punt(2, 6)

Snaren

C++ heeft geen tekenreeks van het basistype. Er is echter een standaardbibliotheek met de naam string, die een klasse biedt voor het werken met strings.

#erbij betrekken #erbij betrekken void main() ( std::string first_name = "Vasya"; std::string last_name = ( "Pupkin"); //string aaneenschakeling auto full_name = voornaam + " " + achternaam; std::string *afdeling = nieuwe std ::string("Afdeling kopiëren en scannen");<< full_name << std::endl; //сравнение строк std::string a = "A"; std::string b = "B"; if (first_name.compare(last_name) >0) (std::cout<< a + " >" + geb<< std::endl; } else { std::cout << a + " < " + b << std::endl; } //подстрока std::string subs = department->substr(0, 10);<< subs << std::endl; //замена подстроки std::cout << last_name.replace(0, 1, "G") << std::endl; //вставка std::string new_department = department->std::uit<< new_department << std::endl; delete department; system("pause"); }

insert(afdeling->lengte(), "en versnippering");

std::uit

We zullen de standaard stringbibliotheek later in meer detail leren kennen.

    Laatste update: 17-09-2017

    Elke variabele heeft een specifiek type. En dit type bepaalt welke waarden een variabele kan hebben, welke bewerkingen erop kunnen worden uitgevoerd en hoeveel bytes het geheugen in beslag zal nemen. De volgende basisgegevenstypen zijn gedefinieerd in de C++-taal:

    bool : booleaans type. Kan een van twee waarden aannemen: waar en onwaar. De geheugenvoetafdruk voor dit type is niet precies gedefinieerd.

    char: vertegenwoordigt een enkel ASCII-teken. Neemt 1 byte (8 bits) in beslag in het geheugen. Kan elke waarde opslaan van -128 tot 127, of van 0 tot 255

    ondertekende char: vertegenwoordigt een enkel teken. Neemt 1 byte (8 bits) in beslag in het geheugen. Kan elke waarde van -128 tot 127 opslaan

    char16_t: vertegenwoordigt een enkel Unicode-teken. Neemt 2 bytes (16 bits) in beslag in het geheugen. Kan elke waarde van 0 tot 65.535 opslaan

    char32_t: vertegenwoordigt een enkel Unicode-teken. Neemt 4 bytes (32 bits) in beslag in het geheugen. Kan elke waarde van 0 tot 4.294.967.295 opslaan

    kort: vertegenwoordigt een geheel getal in het bereik –32768 tot 32767. Neemt 2 bytes (16 bits) geheugen in beslag.

    Dit type heeft ook synoniemen korte int, ondertekende korte int, ondertekende korte.

    unsigned short: vertegenwoordigt een geheel getal in het bereik van 0 tot 65535. Neemt 2 bytes (16 bits) geheugen in beslag.

    Dit type heeft ook een synoniem unsigned short int.

    int: vertegenwoordigt een geheel getal. Afhankelijk van de processorarchitectuur kan deze 2 bytes (16 bits) of 4 bytes (32 bits) in beslag nemen. Het bereik van de grenswaarden kan dienovereenkomstig ook variëren van –32768 tot 32767 (met 2 bytes) of van −2.147.483.648 tot 2.147.483.647 (met 4 bytes). Maar in ieder geval moet de maat groter zijn dan of gelijk zijn aan de maat van het korte type en kleiner dan of gelijk aan de maat van het lange type

    Dit type heeft synoniemen ondertekend int en ondertekend.

    unsigned int : vertegenwoordigt een positief geheel getal. Afhankelijk van de processorarchitectuur kan deze 2 bytes (16 bits) of 4 bytes (32 bits) in beslag nemen, en daarom kan het bereik van grenswaarden variëren: van 0 tot 65535 (voor 2 bytes), of van 0 tot 4.294.967.295 (voor 4 bytes).

    unsigned kan als synoniem voor dit type worden gebruikt

    lang: vertegenwoordigt een geheel getal in het bereik −2.147.483.648 tot 2.147.483.647. Neemt 4 bytes (32 bits) geheugen in beslag.

    Dit type heeft ook synoniemen long int , Signed Long Int en Signed Long

    lang zonder teken: vertegenwoordigt een geheel getal in het bereik van 0 tot 4.294.967.295. Neemt 4 bytes (32 bits) geheugen in beslag.

    Heeft het synoniem een ​​lange int zonder handtekening.

    lang lang : vertegenwoordigt een geheel getal in het bereik van −9.223.372.036.854.775.808 tot +9.223.372.036.854.775.807. Neemt doorgaans 8 bytes (64 bits) geheugen in beslag.

    Heeft synoniemen lang lang int, ondertekend lang lang int en ondertekend lang lang.

    niet-ondertekend lang lang: vertegenwoordigt een geheel getal in het bereik van 0 tot 18.446.744.073.709.551.615. Normaal gesproken 8 bytes (64 bits) in het geheugen.

    Heeft het synoniem niet-ondertekend long long int .

    float : vertegenwoordigt een reëel getal met drijvende komma met enkele precisie in het bereik +/- 3,4E-38 tot 3,4E+38. Neemt 4 bytes (32 bits) in beslag in het geheugen

    double : vertegenwoordigt een reëel getal met drijvende komma met dubbele precisie in het bereik +/- 1,7E-308 tot 1,7E+308. Neemt 8 bytes (64 bits) geheugen in beslag

    lang dubbel: vertegenwoordigt een reëel getal met drijvende komma met dubbele precisie van minimaal 8 bytes (64 bits). Afhankelijk van de grootte van het bezette geheugen kan het bereik van geldige waarden variëren.

    void : typ zonder waarde

Alle gegevenstypen behalve void kunnen dus in drie groepen worden verdeeld: karakter (char, wchar_t, char16_t, char32_t), integer (short, int, long, long long) en drijvende-kommagetaltypen (float, double, long double).

Karaktertypen

De typen die worden gebruikt om tekens in de toepassing weer te geven zijn char, wchar_t, char16_t en char32_t.

Laten we verschillende variabelen definiëren:

Char c = "d"; wchar_t d = "c";

Een char-variabele heeft als waarde één teken tussen enkele aanhalingstekens: char c ="d" . U kunt ook een nummer toewijzen uit het bereik dat hierboven in de lijst is opgegeven: char c = 120 . In dit geval is de waarde van variabele c het teken met code 120 in de ASCII-tekentabel.

Het is de moeite waard om te overwegen dat om wchar_t-tekens naar de console uit te voeren, je niet std::cout moet gebruiken, maar de std::wcout-stream:

#erbij betrekken int main() ( char a = "H"; wchar_t b = "e"; std::wcout<< a << b << "\n"; return 0; }

In dit geval kan de std::wcout-stream werken met zowel char als wchar_t. En de std::cout-stream voor de wchar_t variabele zal zijn numerieke code uitvoeren in plaats van een teken.

De C++11-standaard heeft de typen char16_t en char32_t toegevoegd, die gericht zijn op het gebruik van Unicode. Threads voor het werken met deze typen zijn echter nog niet geïmplementeerd op besturingssysteemniveau. Als u daarom de waarden van variabelen van dit type op de console wilt weergeven, moet u de variabelen converteren naar het type char of wchar_t:

#erbij betrekken int main() ( char a = "H"; wchar_t b = "e"; char16_t c = "l"; char32_t d = "o"; std::cout<< a << (char)b << (char)c << (char)d << "\n"; return 0; }

In dit geval worden de variabelen bij het uitvoeren voorafgegaan door een cast-bewerking naar het char-type - (char) , waardoor de waarden van de variabelen b, c en d worden geconverteerd naar het char-type en kunnen worden uitgevoerd naar de console met behulp van de std::cout-stream.

Typen gehele getallen

Typen gehele getallen worden weergegeven door de volgende typen: short, unsigned short, int, unsigned int, long, unsigned long, long long en unsigned long long:

Kort a = -10; ongetekende korte b= 10; int c = -30; niet-ondertekende int d = 60; lange e = -170; niet-ondertekende lange f = 45; lang lang g = 89;

Soorten drijvende-kommagetallen

Drijvende-komma- en breukgetallen worden weergegeven door float, double en long double:

Zweven a = -10,45; dubbele b = 0,00105; lange dubbele c = 30,890045;

Grootte van gegevenstype

In de bovenstaande lijst wordt voor elk type weergegeven hoeveel ruimte het in het geheugen in beslag neemt. Het is echter vermeldenswaard dat compilerontwikkelaars de groottelimieten voor typen onafhankelijk kunnen kiezen, op basis van de hardwaremogelijkheden van de computer. De standaard stelt alleen de minimumwaarden vast die zouden moeten zijn. Voor de typen int en short is de minimumwaarde bijvoorbeeld 16 bits, voor het lange type 32 bits, voor het lange dubbele type. In dit geval mag de grootte van het lange type niet kleiner zijn dan de grootte van het int-type, en de grootte van het int-type mag niet kleiner zijn dan de grootte van het korte type, en de grootte van het lange dubbele type moet groter zijn dan het dubbele. De g++-compiler voor Windows gebruikt bijvoorbeeld 12 bytes voor lange doubles, en de compiler die in Visual Studio is ingebouwd en ook onder Windows draait, gebruikt 8 bytes voor lange doubles. Dat wil zeggen dat zelfs binnen hetzelfde platform verschillende compilers verschillende benaderingen kunnen hebben met betrekking tot de grootte van bepaalde gegevenstypen. Maar over het algemeen worden de maten gebruikt die hierboven zijn aangegeven bij het beschrijven van gegevenstypen.

Er zijn echter situaties waarin het nodig is om precies de maat van een bepaald type te weten. En hiervoor heeft C++ de operator sizeof(), die de grootte van het geheugen retourneert in bytes die de variabele in beslag neemt:

#erbij betrekken int main() ( lang dubbel getal = 2; std::cout<< "sizeof(number) =" << sizeof(number); return 0; }

Console-uitvoer bij compileren in g++:

groottevan(getal) = 12

Tegelijkertijd is het bij het definiëren van variabelen belangrijk om te begrijpen dat de waarde van een variabele niet verder mag gaan dan de grenzen die voor zijn type zijn aangegeven. Bijvoorbeeld:

Niet-ondertekend kort nummer = -65535;

De G++-compiler zal bij het compileren van een programma met deze regel een foutmelding genereren waarin staat dat de waarde -65535 niet binnen het bereik van geldige waarden voor het niet-ondertekende korte type valt en zal worden afgekapt.

In Visual Studio kan de compilatie zonder fouten doorgaan, maar de variabele number krijgt de waarde 2 - het resultaat van het converteren van het getal -65535 naar een niet-ondertekend kort type. Dat wil zeggen, nogmaals, het resultaat zal niet precies zijn wat verwacht werd. De waarde van een variabele is slechts een verzameling bits in het geheugen die volgens een specifiek type worden geïnterpreteerd. En voor verschillende soorten dezelfde set bits kan anders worden geïnterpreteerd. Daarom is het belangrijk om rekening te houden met de waardebereiken voor een bepaald type wanneer u een waarde aan een variabele toekent.

automatische specificatie

Soms kan het moeilijk zijn om het type expressie te bepalen. En volgens de nieuwste standaarden kun je de compiler het type object zelf laten afleiden. En hiervoor wordt de autospecificatie gebruikt. Als we bovendien een variabele definiëren met de automatische specificatie, moet deze variabele met een bepaalde waarde worden geïnitialiseerd:

Automatisch nummer = 5;

Op basis van de toegewezen waarde zal de compiler het type variabele afleiden. Niet-geïnitialiseerde variabelen met de automatische specificatie zijn niet toegestaan.

Variabelen worden gebruikt om verschillende gegevens in programmeertalen op te slaan. Een variabele is een geheugengebied dat een naam heeft, ook wel een identificatie genoemd.

Door een variabele een naam te geven, geeft de programmeur tegelijkertijd het geheugengebied een naam waar de waarden van de variabele zullen worden geschreven voor opslag.

Het is een goede stijl om variabelen betekenisvol te benoemen. Het is toegestaan ​​om kleine en hoofdletters, cijfers en het onderstrepingsteken te gebruiken, dat in C als een letter wordt beschouwd. Het eerste teken moet een letter zijn en er mogen geen spaties in de naam van de variabele voorkomen. In moderne versies van compilers is de naamlengte vrijwel onbeperkt. De variabelenaam mag niet overeenkomen met gereserveerde trefwoorden. Hoofdletters en kleine letters in namen van variabelen zijn verschillende variabelen A En A- verschillende variabelen.

Gereserveerde trefwoorden auto double int struct break else long switch register tupedef char extern return void case float unsigned standaard voor ondertekende unie do if sizeof volatile continue enum short while
In C moeten alle variabelen worden gedeclareerd. Dit betekent dat u ten eerste aan het begin van elk programma of elke functie een lijst moet opgeven met alle gebruikte variabelen, en ten tweede het type van elk ervan moet aangeven.

Wanneer een variabele wordt gedeclareerd, wijst de compiler er geheugenruimte voor toe, afhankelijk van het type. Met behulp van standaard AVR GCC-tools werkt het met gegevenstypen verkoold(tekentype) en int(geheel type).

Variabele typen

Typ teken

verkoold- is het meest economische type. Het char-type kan ondertekend of niet-ondertekend zijn. Dienovereenkomstig aangeduid als " ondertekende char" (ondertekend type) en " niet-ondertekend teken" (niet-ondertekend type). Het ondertekende type kan waarden opslaan in het bereik van -128 tot +127. Niet-ondertekend - van 0 tot 255. Een char-variabele heeft 1 byte geheugen (8 bits).

Trefwoorden (modificatoren) ondertekend En niet ondertekend geef aan hoe de nulbit van de gedeclareerde variabele wordt geïnterpreteerd, dat wil zeggen: als het sleutelwoord zonder teken is gespecificeerd, wordt de nulbit geïnterpreteerd als onderdeel van een getal, anders wordt de nulbit geïnterpreteerd als ondertekend.

Typ int

Gehele waarde int Misschien kort(kort) of lang(lang).

Zoekwoord (modificator) kort geplaatst na trefwoorden ondertekend of niet ondertekend. Er worden dus de volgende typen onderscheiden: ondertekende korte int, niet-ondertekende korte int, ondertekende lange int, niet-ondertekende lange int.

Typ variabele gesigneerd korte int(kort geheel getal met teken) kan waarden aannemen van -32768 tot +32767, niet-ondertekende korte int(kort geheel getal zonder teken) - van 0 tot 65535. Voor elk van hen worden precies twee bytes geheugen (16 bits) toegewezen.

Bij het declareren van een typevariabele gesigneerd korte int trefwoorden ondertekend En kort kan worden weggelaten, en een dergelijk variabel type kan eenvoudig worden gedeclareerd int. Het is ook mogelijk om dit type met één trefwoord te declareren kort.

Variabel niet-ondertekende korte int kan worden verklaard als niet ondertekend int of niet-ondertekende korte.

Voor elke maat gesigneerd lange int of niet-ondertekend lange int Er wordt 4 bytes geheugen toegewezen (32 bits). De waarden van variabelen van dit type kunnen respectievelijk in het bereik liggen van -2147483648 tot 2147483647 en van 0 tot 4294967295.

Er zijn ook variabelen zoals lang lang int, waarvoor 8 bytes geheugen zijn toegewezen (64 bits). Ze kunnen ook ondertekend of niet-ondertekend zijn. Voor een ondertekend type loopt het waardenbereik van -9223372036854775808 tot 9223372036854775807, voor een niet-ondertekend type - van 0 tot 18446744073709551615. Een ondertekend type kan eenvoudigweg met twee trefwoorden worden gedeclareerd. lang lang.

Type Bereik Hex-bereik Maat
niet-ondertekend teken 0 ... 255 0x00...0xFF 8 bit
ondertekende char
of gewoon
verkoold 		-128 ... 127 -0x80...0x7F 8 bit
niet-ondertekende korte int
of gewoon
niet ondertekend int of niet-ondertekende korte 		0 ... 65535 0x0000 ... 0xFFFF 16 bits
gesigneerd korte int of ondertekend int
of gewoon
kort of int 		-32768 ... 32767 0x8000...0x7FFF 16 bits
niet-ondertekend lange int
of gewoon
lang niet ondertekend 		0 ... 4294967295 0x00000000 ... 0xFFFFFFFF 32 bits
lang getekend
of gewoon
lang 		-2147483648 ... 2147483647 0x80000000 ... 0x7FFFFFFFF 32 bits
niet ondertekend lang lang 0 ... 18446744073709551615 0x0000000000000000 ... 0xFFFFFFFFFFFFFFFF 64 bits
lang getekend
of gewoon
lang lang 		-9223372036854775808 ... 9223372036854775807 0x8000000000000000 ... 0x7FFFFFFFFFFFFFFFF 64 bits

Variabelen worden gedeclareerd in een declaratieverklaring. Een declaratie-instructie bestaat uit een typespecificatie en een door komma's gescheiden lijst met namen van variabelen. Er moet een puntkomma aan het einde staan.

Een variabelendeclaratie heeft het volgende formaat:

[modifiers] type_specificatie identifier [, identifier] ...

Modificatoren- trefwoorden ondertekend, niet ondertekend, kort, lang.
Typespecificatie- trefwoord verkoold of int, die het type van de gedeclareerde variabele bepaalt.
Identificatie- naam van de variabele.

Voorbeeld: teken x;
int a, b, c; niet-ondertekend lang lang y;, A, Op deze manier worden de variabelen gedeclareerd, X, B C niet-ondertekend lang lang y; j A, Op deze manier worden de variabelen gedeclareerd, X- van -32768 tot +32767. Naar een variabele B- van 0 tot 18446744073709551615.

Initialiseren van de waarde van een variabele bij declaratie

Wanneer een variabele wordt gedeclareerd, kan deze worden geïnitialiseerd, dat wil zeggen dat er een initiële waarde aan wordt toegewezen. U kunt dit als volgt doen. niet-ondertekend lang lang y; intx = 100; Dus in de variabele

Bij bekendmaking wordt het getal 100 direct opgeschreven.

Het is beter om te voorkomen dat geïnitialiseerde variabelen in één declaratie-instructie door elkaar worden gebruikt, dat wil zeggen dat het beter is om geïnitialiseerde variabelen op afzonderlijke regels te declareren.

Constanten Een variabele van elk type kan onveranderbaar worden verklaard. Dit wordt bereikt door het trefwoord toe te voegen const Een variabele van elk type kan onveranderbaar worden verklaard. Dit wordt bereikt door het trefwoord toe te voegen aan de typeaanduiding. Variabelen met type Een variabele van elk type kan onveranderbaar worden verklaard. Dit wordt bereikt door het trefwoord toe te voegen zijn alleen-lezen gegevens, wat betekent dat er geen nieuwe waarde aan de variabele kan worden toegewezen. Als na het woord int of lang int Als er geen typespecificatie is, worden constanten behandeld als waarden met teken en krijgen ze een type toegewezen int volgens de waarde van de constante: als de constante kleiner is dan 32768, wordt het type toegewezen lang int.

, anders Voorbeeld: const long int k = 25; const m = -50; // impliciete const int m=-50

const n = 100000;

// impliciete const long int n=100000

Opdracht
Het teken "= wordt gebruikt voor toewijzing in C. De uitdrukking rechts van het toewijzingsteken wordt geëvalueerd en de resulterende waarde wordt toegewezen aan de variabele links van het toewijzingsteken. In dit geval wordt de vorige waarde die in de variabele is opgeslagen, gewist en vervangen door een nieuwe.

De operator "= mag niet worden opgevat als gelijkheid. De uitdrukking a = 5; moet worden gelezen als "wijs variabele a toe aan 5". Voorbeelden: x = 5 + 3; // voeg de waarden 5 en 3 toe, // wijs het resultaat toe aan variabele x (schrijf naar variabele x) b = a + 4; // voeg 4 toe aan de waarde opgeslagen in variabele a, // wijs het resulterende resultaat toe aan variabele b (schrijf naar variabele b)
b = b + 2;

// voeg 2 toe aan de waarde opgeslagen in variabele b, // wijs het resulterende resultaat toe aan variabele b (schrijf naar variabele b) Aan de rechterkant kan de waarde van de variabele meerdere keren worden gebruikt: c = b * b + 3 * b; Voorbeeld: x = 3; // variabele x krijgt de waarde 3 toegewezen y = x + 5; // het getal 5 wordt opgeteld bij de waarde die is opgeslagen in de x-variabele, // het resulterende resultaat wordt naar de y-variabele geschreven z = x * y; // de waarden van de variabelen x en y worden vermenigvuldigd, // het resultaat wordt naar de variabele z geschreven
z = z-1; z het nummer 23 wordt opgeslagen

Naast de eenvoudige toewijzingsoperator "=" zijn er nog een aantal gecombineerde toewijzingsoperatoren in C: "+=", "-=", "*=
Voorbeelden: x += y; // hetzelfde als x = x + y; - voeg x en y // toe en schrijf het resultaat naar de variabele x x -= y; // hetzelfde als x = x - y; - trek de waarde y af van x // en schrijf het resultaat naar de variabele x x *= y; // hetzelfde als x = x * y; - vermenigvuldig x met y // en schrijf het resultaat naar de variabele x x /= y; // hetzelfde als x = x / y; - deel x door y // en schrijf het resultaat naar de variabele x x %= j; // hetzelfde als x = x% y;

// bereken de rest van het gehele getal bij het delen van x door y // en schrijf het resultaat naar de variabele x

Verhogen en verlagen Als u de waarde van een variabele wilt wijzigen in 1, gebruik dan of verhogen.

verlagen Verhogen

- de bewerking waarbij de in een variabele opgeslagen waarde met 1 wordt verhoogd. Voorbeeld: x++;// de waarde van de variabele x wordt met 1 verhoogd
$WinAVR = ($_GET["gem"]); if($WinAVR) include($WinAVR);?> Verlagen

- de bewerking waarbij de in een variabele opgeslagen waarde met 1 wordt verlaagd. Voorbeeld: x--;
// de waarde van de variabele x wordt met 1 verlaagd

Verhogen en verlagen zijn toewijzingsoperatoren. Wanneer u verlagen en verhogen samen met de toewijzingsoperator "=" gebruikt, gebruik dan de notatie postfix (x++) of prefix (++x). De prefixinvoer wordt eerst uitgevoerd.
Voorbeelden: y = x++; niet-ondertekend lang lang y; Laten we aannemen dat dit in de variabele is B Vervolgens werd de waarde 5 opgeslagen niet-ondertekend lang lang y; de waarde 5 wordt geschreven, waarna de waarde van de variabele B wordt met 1 verhoogd. Dus in niet-ondertekend lang lang y; zal 5 zijn, en in
- 6. y = --x; niet-ondertekend lang lang y; Als binnen niet-ondertekend lang lang y; Als de waarde 5 is opgeslagen, wordt eerst de verlaging uitgevoerd B tot 4 en vervolgens wordt deze waarde aan de variabele toegewezen niet-ondertekend lang lang y; En B. Dus,

krijgt de waarde 4 toegewezen. In deze les ga je het leren C++ taalalfabet , en ook wat gegevenstypen

  • het programma kan het verwerken. Dit is misschien niet het meest opwindende moment, maar deze kennis is noodzakelijk! Bovendien, als je een andere programmeertaal gaat leren, zul je met meer zelfvertrouwen een soortgelijke leerfase doormaken. Een C++-programma kan de volgende symbolen bevatten:
  • hoofdletters, kleine letters Latijnse letters A, B, C..., x, y, z en onderstrepingsteken;
  • Arabische cijfers van 0 tot 9;< > = ! & # ~ ; ^
  • speciale tekens: ( ) , | , () + - / % * . \‘: ?

spatie-, tab- en nieuweregeltekens. Bij het testen van programma's kunt u gebruik maken van opmerkingen

Gegevens in C++

Om een ​​probleem op te lossen, verwerkt elk programma bepaalde gegevens. Ze kunnen van verschillende typen zijn: gehele getallen en reële getallen, tekens, strings, arrays. In C++ worden gegevens meestal aan het begin van de functie beschreven. NAAR basisgegevenstypen talen zijn onder meer:

Om andere soorten gegevens te genereren, eenvoudig en zogenaamd specificeerders. C++ definieert vier gegevenstypespecificaties:

  • kort - kort;
  • lang - lang;
  • ondertekend - ondertekend;
  • niet ondertekend - niet ondertekend.

Type geheel getal

Typ variabele int in het computergeheugen kan 2 of 4 bytes in beslag nemen. Het hangt af van de bitgrootte van de processor. Standaard worden alle typen gehele getallen als ondertekend beschouwd, dat wil zeggen als de specificatie ondertekend mag niet gespecificeerd worden. Specificator niet ondertekend Hiermee kunt u alleen positieve getallen weergeven. Hieronder vindt u enkele bereiken van waarden van het gehele type

Type Bereik Maat
int -2147483648…2147483647 4 bytes
niet ondertekend int 0…4294967295 4 bytes
ondertekend int -2147483648…2147483647 4 bytes
korte int -32768…32767 2 bytes
lang int -2147483648…2147483647 4 bytes
niet-ondertekende korte int 0…65535 2 bytes

Echt soort

Een getal met drijvende komma wordt weergegeven in de vorm mE +- p, waarbij m de mantisse is (geheel getal of breukgetal met een decimaalpunt), p de exponent (geheel getal). Typisch waarden zoals vlot neemt 4 bytes in beslag, en dubbele 8 bytes. Tabel met reële waardebereiken:

vlot 3,4E-38…3,4E+38 4 bytes
dubbele 1.7E-308…1.7E+308 8 bytes
lange dubbele 3.4E-4932…3.4E+4932 8 bytes

Booleaans type

Typ variabele bool kan slechts twee waarden aannemen WAAR ( WAAR ) of makkelijk ( leugen ). Elke waarde die niet gelijk is aan nul wordt geïnterpreteerd als WAAR. Betekenis vals in het geheugen weergegeven als 0.

typ leegte

De waardenset van dit type is leeg. Het wordt gebruikt om functies te definiëren die geen waarde retourneren, om een ​​lege lijst met functieargumenten op te geven, als het basistype voor pointers, en bij typecast-bewerkingen.

Conversie van gegevenstypen

In C++ zijn er twee soorten gegevenstypeconversie: expliciet en impliciet.

  • Impliciete conversie gebeurt automatisch. Dit gebeurt tijdens het vergelijken, toewijzen of evalueren van uitdrukkingen van verschillende typen. Het volgende programma zal bijvoorbeeld een waarde als vlot

#include "stdafx.h" #include naamruimte std gebruiken; int main() ( int i=5; float f=10.12; cout<>ongeldig"); retourneert 0; )

#include "stdafx.h"

#erbij betrekken

naamruimte std gebruiken;

int hoofd()

int ik = 5; vlotter f = 10,12;

uit<< i / f ;

systeem ("pauze>>void" );

retour 0;

De hoogste prioriteit wordt gegeven aan het type waarbij de minste hoeveelheid informatie verloren gaat. U moet niet te veel gebruik maken van impliciete typeconversie, aangezien zich verschillende onvoorziene situaties kunnen voordoen.

  • Expliciete conversie in tegenstelling tot impliciet wordt het uitgevoerd door de programmeur. Er zijn verschillende manieren om deze conversie uit te voeren:
  1. Converteren naar stijlen C: (zweven) een
  2. Converteren naar stijlen C++: vlot()

Typecasting kan ook worden uitgevoerd met behulp van de volgende bewerkingen:

statische_cast<>() const_cast<>() herinterpreteer_cast<>() dynamische_cast<> ()

statische_cast<> ()

const_cast<> ()

herinterpreteer_cast<> ()

dynamische_cast<> ()

statisch_cas- converteert gerelateerde gegevenstypen. Deze operator cast typen volgens de gebruikelijke regels, wat nodig kan zijn als de compiler geen automatische conversie uitvoert. De syntaxis ziet er als volgt uit:

Typ static_cast<Тип>(voorwerp);

Met static_cast kunt u de constantheid van een variabele niet verwijderen, maar de volgende operator kan dit wel doen. const_cast- wordt alleen gebruikt als het nodig is om de constantheid van een object te verwijderen. De syntaxis ziet er als volgt uit:

Typeconst_cast< Type> (voorwerp);

herinterpreteer_cast- gebruikt om verschillende typen te converteren, geheel getal naar aanwijzer en omgekeerd. Als u een nieuw woord "index" ziet, hoeft u zich geen zorgen te maken! Dit is ook een gegevenstype, maar we zullen er niet snel mee werken. De syntaxis is hier dezelfde als die van de eerder besproken operators:

Typeherinterpreteren_vorm< Type> (voorwerp);

dynamische_cast- gebruikt voor dynamische conversie typen, implementeert het casten van pointers of referenties. Syntaxis:

Typedynamisch _vorm< Type> (voorwerp);

Controlekarakters

U bent al bekend met enkele van deze “controlekarakters” (bijvoorbeeld met \N). Ze beginnen allemaal met een backslash en worden ook omgeven door dubbele aanhalingstekens.

Afbeelding

Hex-code

Naam

Pieper geluid

Ga een stap terug

Vertaling van pagina (formaat)

Lijnvoeding

Vervoer terug

Horizontale tabellering

Verticaal tabblad


GERELATEERDE ARTIKELEN