Variabelen van het type int voorbeeld. Gegevenstypen in C-taal

Bij het programmeren is een datatype een verzameling van twee sets: een set waarden en een set bewerkingen die daarop kunnen worden toegepast. De bewerkingen optellen (+), vermenigvuldigen (*), delen van gehele getallen (/), rest (%) en aftrekken (-) kunnen bijvoorbeeld worden toegepast op een niet-negatief gegevenstype met gehele getallen dat bestaat uit een eindige reeks natuurlijke getallen.

Een programmeertaal heeft doorgaans een reeks primitieve gegevenstypen: typen die door de programmeertaal worden geleverd als een ingebouwde basiseenheid. In C++ noemt de maker van de taal dergelijke typen fundamentele typen. De fundamentele typen in C++ zijn:

• booleaans(bool);
• karakter (bijv. char);
• int (bijvoorbeeld int);
• drijvende komma (bijv. float);
• opsommingen (gedefinieerd door de programmeur);
• leegte .

Bovenop de genoemde typen zijn de volgende typen gebouwd:

• demonstratief (bijv. int*);
• arrays (bijv. char);
• referentie (bijv. dubbel&);
• andere structuren.

Laten we verder gaan met het concept van een letterlijke waarde (bijvoorbeeld 1, 2.4F, 25e-4, 'a', enz.): een letterlijke waarde is een vermelding in de broncode van een programma die een vaste waarde vertegenwoordigt. Met andere woorden, een letterlijke waarde is eenvoudigweg een weergave van een object (waarde) van een bepaald type in programmacode. C++ heeft de mogelijkheid om integer-, floating-point-, karakter-, boolean- en stringwaarden te schrijven.

Een letterlijk geheel getaltype kan worden geschreven als:

• 10e nummersysteem. Bijvoorbeeld 1205;
• 8e nummersysteem in het formaat 0 + nummer. Bijvoorbeeld 0142;
• 16e nummersysteem in het formaat 0x + nummer. Bijvoorbeeld 0x2F.

24, 030, 0x18 - dit zijn allemaal records van hetzelfde nummer in verschillende nummersystemen.
Om getallen met drijvende komma te schrijven, gebruikt u puntnotatie: 0,1, 0,5, 4. - ofwel in
exponentiële notatie - 25e-100. In zo'n record mogen geen spaties voorkomen.

De naam waarmee we waarden kunnen associëren die in letterlijke letters zijn geschreven, wordt een variabele genoemd. Een variabele is een benoemd of anderszins adresseerbaar geheugengebied waarvan het adres kan worden gebruikt om toegang te krijgen tot gegevens. Deze gegevens worden tijdens de uitvoering van het programma op een bepaalde manier in het geheugen geschreven, herschreven en gewist. Met een variabele kunt u op elk moment toegang krijgen tot gegevens en deze indien nodig wijzigen. Gegevens die uit een variabelenaam kunnen worden opgehaald, worden de waarde van de variabele genoemd.
Om een ​​variabele in een programma te kunnen gebruiken, moet deze worden gedeclareerd en indien nodig kan deze worden gedefinieerd (= geïnitialiseerd). De declaratie van een variabele in de programmatekst bestaat noodzakelijkerwijs uit twee delen: het basistype en de declarator. De specificatie en initialisator zijn optionele onderdelen:

Const int voorbeeld = 3; // hier is const een specificatie // int is het basistype // voorbeeld is de naam van de variabele // = 3 - initialisatie.

De naam van de variabele is een reeks tekens bestaande uit letters van het Latijnse alfabet (kleine letters en hoofdletters), cijfers en/of een onderstrepingsteken, maar het eerste teken mag geen cijfer zijn. De naam van de variabele moet zo worden gekozen dat het altijd gemakkelijk is om te raden wat erin staat, bijvoorbeeld ‘maandbetaling’. In de toelichting en in de praktijk zullen we de CamelCase-notatie gebruiken voor de regels voor het vastleggen van variabelen. De naam van de variabele kan niet samenvallen met woorden die in de taal zijn gereserveerd; voorbeelden van dergelijke woorden zijn: if, while, function, goto, switch, etc.

Naast de naam van de variabele kan de declarator extra tekens bevatten:

• * - wijzer; vóór de naam;
• *const - constante aanwijzer; vóór de naam;
• & - koppeling; vóór de naam;
• - reeks; achter de naam;
• () - functie; achter de naam.

Met een initialisatiefunctie kunt u onmiddellijk na de declaratie ervan een waarde voor een variabele definiëren. De initialisatie begint met een letterlijke gelijkheid (=) en gaat vervolgens verder met het instellen van de waarde van de variabele. Over het algemeen duidt het gelijkteken in C++ een toewijzingsoperatie aan; met zijn hulp kun je de waarde van een variabele instellen en wijzigen. Het kan voor verschillende typen verschillend zijn.

De specificatie specificeert aanvullende attributen, behalve het type. Met de const-specificatie uit het voorbeeld kunt u latere wijzigingen in de waarde van de variabele verbieden. Dergelijke onveranderlijke variabelen worden constant of constant genoemd.

Het declareren van een constante zonder initialisatie zal om logische redenen niet werken:

Const int EMPTY_CONST; // fout, constante variabele is niet geïnitialiseerd const int VOORBEELD = 2; // constante met waarde 2 VOORBEELD = 3; // error, poging om een ​​waarde toe te wijzen aan een constante variabele

Bij het benoemen van constanten is het gebruikelijk om alleen hoofdletters te gebruiken, waarbij woorden worden gescheiden door een onderstrepingsteken.

Basisgegevenstypen in C++

Bij het onderzoeken van elk type mag de lezer de definitie van het gegevenstype niet vergeten.

1. Type geheel getal (char, short (int), int, long (int), long long)

Uit de naam is het gemakkelijk te begrijpen dat de reeks waarden uit gehele getallen bestaat. Ook kan de reeks waarden van elk van de vermelde typen ondertekend of niet-ondertekend zijn. Het aantal elementen in een set hangt af van de grootte van het geheugen dat wordt gebruikt om de waarde van dat type op te slaan. Voor een variabele van het type char wordt bijvoorbeeld 1 byte geheugen toegewezen, dus het totaal aantal elementen is:

• 2 8N = 2 8 * 1 = 256, waarbij N de grootte is van het geheugen in bytes om de waarde op te slaan

In dit geval zijn de bereiken van beschikbare gehele getallen als volgt:

• - voor niet-ondertekende char
• [-128..127] - voor ondertekende tekens

Standaard wordt een integer-variabele als ondertekend beschouwd. Om in de code aan te geven dat een variabele niet-ondertekend moet zijn, wordt aan de linkerkant een ondertekend attribuut toegevoegd aan het basistype, d.w.z. niet ondertekend:

Niet-ondertekende lange waarden; // specificeert een geheel getal (lang) zonder teken.

De genoemde typen verschillen alleen in de grootte van het geheugen dat nodig is voor opslag. Omdat de C++-taal behoorlijk machine-afhankelijk is, garandeert de taalstandaard alleen de volgende voorwaarde:

• 1 = char-grootte ≤ korte grootte ≤ int-grootte ≤ lange grootte.

Meestal zijn de grootten van typen als volgt: char - 1, short - 2, int - 4, long -8, long long - 8 bytes.

U kunt rekenkundige bewerkingen uitvoeren met waarden van het gehele type: +, -, *, /,%; vergelijkingsbewerkingen: ==, !=,<=, <, >, >=; bitbewerkingen: &, |, xor,<<, >>.
De meeste bewerkingen, zoals optellen, vermenigvuldigen, aftrekken en vergelijken, zijn gemakkelijk te begrijpen. Soms kan het resultaat na het uitvoeren van rekenkundige bewerkingen buiten het bereik van waarden vallen; in dit geval zal het programma een fout genereren.
Deling van gehele getallen (/) berekent het gehele getal van het ene gehele getal gedeeld door het andere. Bijvoorbeeld:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Het percentagesymbool (%) geeft de bewerking aan van het bepalen van de rest van de deling van twee gehele getallen:

• 6 % 4 = 2;
• 10 % 3 = 1.

Moeilijker te begrijpen bewerkingen zijn bitsgewijze bewerkingen: & (AND), | (OR), xor (exclusief OR),<< (побитовый сдвиг влево), >> (bitsgewijze verschuiving naar rechts).

De bitbewerkingen AND, OR en XOR passen de overeenkomstige logische bewerking toe op elk informatiebit:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xof 3 10 = 01 2 xof 11 2 = 10 2

Bij beeldverwerking worden voor kleur 3 kanalen gebruikt: rood, blauw en groen - plus transparantie, die worden opgeslagen in een int-variabele, omdat elk kanaal heeft een bereik van waarden van 0 tot 255. In het hexadecimale getalsysteem wordt een bepaalde waarde als volgt geschreven: 0x180013FF; dan komt de waarde 18 16 overeen met het rode kanaal, 00 16 - blauw, 13 16 - groen, FF - alfakanaal (transparantie). Om uit zo’n geheel getal een specifiek kanaal te selecteren, wordt gebruik gemaakt van het zogenaamde kanaal. masker, waarbij de voor ons interessante posities F 16 of 1 2 zijn. Dat wil zeggen, om de waarde van het blauwe kanaal te benadrukken, moet u een masker gebruiken, d.w.z. bitgewijs EN:

Int blauw_kanaal = 0x180013FF & 0x00FF0000;

Daarna wordt de resulterende waarde met het vereiste aantal bits naar rechts verschoven.

Een bitverschuiving verschuift een getal naar links of rechts met zoveel binaire cijfers als aangegeven aan de rechterkant van de bewerking. Het getal 39 voor het char-type wordt bijvoorbeeld als volgt binair geschreven: 00100111. Vervolgens:

Char binairVoorbeeld = 39; // 00100111 char resultaat = binaryExample<< 2; // сдвигаем 2 бита влево, результат: 10011100

Als de variabele een niet-ondertekend type is, is het resultaat het getal 156, voor een ondertekend type is dit gelijk aan -100. Merk op dat voor typen gehele getallen met teken een eenheid in de meest significante bit van de bitrepresentatie een teken is dat het getal negatief is. In dit geval komt een waarde in binaire vorm bestaande uit allemaal enen overeen met -1; als 1 alleen in het meest significante cijfer staat en de overige cijfers nullen zijn, dan heeft zo'n getal de minimumwaarde voor een bepaald type: voor char is het -128.

2. Type met drijvende komma (zwevend, dubbel (zwevend))

De reeks waarden met drijvende komma is een subset van reële getallen, maar niet elk reëel getal is in binaire vorm representeerbaar, wat soms tot domme fouten leidt:

Zwevende waarde = 0,2; waarde == 0,2; // fout, waarde hier is niet gelijk aan 0,2.

Bij het werken met variabelen met drijvende komma mag de programmeur geen gelijkheids- of ongelijkheidstest gebruiken; meestal wordt een test gebruikt om binnen een bepaald interval te vallen:

Waarde - 0,2< 1e-6; // ok, подбирать интервал тоже нужно осторожно

Naast vergelijkingsbewerkingen ondersteunt het drijvende-kommatype 4 rekenkundige bewerkingen die volledig overeenkomen met wiskundige bewerkingen met reële getallen.

3. Booleaans (logisch) type (bool)

Bestaat uit slechts twee waarden: true (waar) en false (false). Om met dit soort variabelen te werken, worden logische bewerkingen gebruikt: ! (NIET), == (gelijkheid), != (ongelijkheid), && (logisch EN), || (logisch OF). Het resultaat van elke bewerking is te vinden in de bijbehorende waarheidstabel. Bijvoorbeeld:

4. Tekentype (char, wchar_t)

Het char-type is niet alleen een geheel getal-type (meestal wordt dit type byte genoemd), maar ook een tekentype, waarbij het tekennummer uit de tabel wordt opgeslagen als een ASCII-teken. Code 0x41 komt bijvoorbeeld overeen met het teken 'A' en 0x71 - 't'.

Soms wordt het nodig om tekens te gebruiken die niet vastgelegd zijn in ASCII-tabellen en daarom meer dan 1 byte nodig hebben voor opslag. Er is een breed karakter voor hen (wchar_t).

5.1. Arrays

Met arrays kunt u een opeenvolgende reeks elementen van hetzelfde type opslaan. Een array wordt in het geheugen opgeslagen als een aaneengesloten blok, dus u kunt een array niet declareren zonder de grootte ervan op te geven. Om een ​​array te declareren, worden vierkante haakjes () achter de naam van de variabele geschreven, die de grootte ervan aangeeft. Bijvoorbeeld:

Int mijnArray; // Array van 5 elementen van het integer-type

Om een ​​array te initialiseren, worden waarden tussen accolades weergegeven. U kunt op deze manier alleen initialiseren op het moment dat de variabele wordt gedeclareerd. Overigens is het in dit geval niet nodig om de grootte van de array op te geven:

Int-kansen = (1, 3, 7, 9, 11); // De array wordt geïnitialiseerd met 5 waarden

Om toegang te krijgen tot een specifieke waarde in een array (array-element), gebruikt u de indextoegangsbewerking () die het elementnummer aangeeft (getallen beginnen vanaf 0). Bijvoorbeeld:

Kansen; // toegang tot het eerste element van de array. Retourneert de waarde 1 odds; // toegang tot het derde element. Retourneert de waarde 7 odds = 13; // Wijs een nieuwe waarde toe aan het 5e element van de array-odds; // toegangsfout

5.3. Snaren

Om een ​​string te schrijven, gebruiken programmeurs het idee dat een string een opeenvolgende reeks (array) tekens is. Om het einde van een regel te identificeren, gebruikt u het speciale regeleindeteken: '\0'. Deze speciale tekens, bestaande uit een backslash en een identificerend teken, worden controle- of escape-tekens genoemd. Er zijn bijvoorbeeld ook '\n' - het begin van een nieuwe regel, '\t' - tabellering. Om een ​​backslash in een string te schrijven, wordt escape gebruikt; er wordt nog een schuine streep vóór het teken zelf geplaatst: ‘\’. Ontsnappen wordt ook gebruikt om aanhalingstekens te schrijven.

Laten we een stringvariabele maken:

Char textExample = ('T', 'e', ​​​​'s', 't', '\0'); // de string “Test” is geschreven

Er is een vereenvoudigde notatie voor stringinitialisatie:

Char textExample = “Test”; // Het laatste teken is niet geschreven, maar de grootte is nog steeds 5

Zonder in details te treden: hier is nog een nuttig gegevenstype: string. Snaren
Dit type kan bijvoorbeeld worden toegevoegd:

Tekenreeks hallo = "Hallo,"; stringnaam = "Max!"; string hallo_naam = hallo + naam; // Haal de string "Hallo, Max!"

6. Koppeling

Int a = 2; // variabele "a" verwijst naar waarde 2 int &b = a; // variabele “b” verwijst naar dezelfde plaats als “a” b = 4; // door de waarde van b te veranderen, verandert de programmeur de waarde van a. Nu a = 4 int &c = 4; // fout, je kunt dit niet doen omdat referentie kan geen waarde worden toegewezen

7. Indexering

Om dit gegevenstype te begrijpen, moet u onthouden dat veel waarden van dit type de adressen zijn van geheugencellen waar de gegevens beginnen. De aanwijzer ondersteunt ook bewerkingen voor optellen (+), aftrekken (-) en derefereren (*).

Adressen 0x0 betekent dat de aanwijzer leeg is, d.w.z. verwijst niet naar gegevens. Dit adres heeft zijn eigen letterlijke waarde: NULL:

Int *nullPtr = NULL; // nulaanwijzer

Het optellen en aftrekken van een adres met een geheel getal of een ander adres is mogelijk
het beschikbare geheugen voor het programma verplaatsen.

De bewerking waarbij gegevens worden opgehaald vanaf een adres dat is opgeslagen in een pointer, wordt dereferentie (*) genoemd. Het programma leest het vereiste aantal geheugencellen en retourneert de in het geheugen opgeslagen waarde.

Int waardeInGeheugen = 2; // stel een variabele van het gehele type int in *somePtr = // kopieer het adres van de variabele, hier & - retourneert het adres van de variabele somePtr; // adres van de geheugencel, bijvoorbeeld 0x2F *somePtr; // de waarde wordt opgeslagen in 4 cellen: 0x2F, 0x30, 0x31 en 0x32

De toewijzingsbewerking, die syntactisch hetzelfde is als de kopieerbewerking, is niet beschikbaar voor pointers. Met andere woorden: u kunt het adres van een andere pointer of het adres van een variabele kopiëren, maar u kunt de waarde van het adres niet zelf bepalen.

De aanwijzer zelf wordt in het geheugen opgeslagen, net als de waarden van variabelen van andere typen, en beslaat 4 bytes, zodat u een aanwijzer naar een aanwijzer kunt maken.

8. Overboekingen

Opsommingen zijn het enige basistype dat door de programmeur is gedefinieerd. Over het algemeen is een opsomming een geordende reeks benoemde gehele constanten, waarbij de naam van de opsomming het basistype is.

Enumkleur (ROOD, BLAUW, GROEN);

Standaard is ROOD = 0, BLAUW = 1, GROEN = 2. Daarom kunnen de waarden met elkaar worden vergeleken, d.w.z. ROOD< BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum-toegang (READ = 1, WRITE = 2, EXEC = 4);

Het is vaak handig om opsommingen te gebruiken waarvan de waarden machten van twee zijn, omdat bij binaire representatie zal een getal dat een macht van 2 is, bestaan ​​uit 1 en nullen. Bijvoorbeeld:

8 10 = 00001000 2

Het resultaat van het optellen van deze getallen geeft altijd duidelijk aan welke getallen zijn opgeteld:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Leegte

Syntactisch gezien behoort het void-type tot de fundamentele typen, maar het kan alleen worden gebruikt als onderdeel van complexere typen, omdat Er zijn geen objecten van het type void. Normaal gesproken wordt dit type gebruikt om aan te geven dat een functie geen retourwaarde heeft of als basistype van een verwijzing naar objecten van ongedefinieerde typen:

Leeg voorwerp; // error, er zijn geen objecten van het type void void // error, er zijn geen verwijzingen naar void void *ptr; // ok, sla een verwijzing op naar een onbekend type

Vaak gebruiken we void specifiek om aan te geven dat een functie geen enkele waarde retourneert. Een void type pointer wordt gebruikt wanneer de programmeur de volledige verantwoordelijkheid op zich neemt voor de integriteit van het geheugen en het correct casten van het type.

Type gieten

Het is vaak nodig om de waarde van een variabele van het ene type naar het andere te casten. In het geval dat de reeks waarden van het oorspronkelijke type een subset van een groter type is (int is bijvoorbeeld een subset van long en long is een double), kan de compiler impliciet ( impliciet) wijzig het waardetype.

geheel getal = 2; zwevend = geheel getal; // zwevend = 2.0

Een omgekeerde cast zal worden uitgevoerd met verlies van informatie, dus alleen het gehele deel van het drijvende-kommagetal zal overblijven, het fractionele deel zal verloren gaan.

Er is de mogelijkheid tot expliciete typeconversie; schrijf links van de variabele of een waarde van het originele type tussen haakjes het type waarnaar de cast zal worden uitgevoerd:

Int-waarde = (int) 2,5;

Unaire en binaire bewerkingen

De bewerkingen die we eerder uitvoerden heten binair: links en rechts van het bewerkingssymbool staan ​​waarden of variabelen, bijvoorbeeld 2+3. Naast binaire bewerkingen gebruiken programmeertalen ook unaire bewerkingen die van toepassing zijn op variabelen . Ze kunnen zich links of rechts van een variabele bevinden; er zijn al eerder dergelijke bewerkingen tegengekomen - de dereferentiebewerking (*) en het nemen van het adres van een variabele (&) zijn unair. De operatoren “++” en “—” verhogen en verlagen de waarde van een integer-variabele met respectievelijk 1, en kunnen links of rechts van de variabele worden geschreven.

C++ gebruikt ook een verkorte notatie voor binaire bewerkingen in het geval dat de linker- en rechterkant van een uitdrukking dezelfde variabele bevatten, d.w.z. er wordt een bewerking uitgevoerd op de waarde van een variabele en het resultaat van de bewerking wordt in dezelfde variabele ingevoerd:

EEN+= 2; // hetzelfde als a = a + 2; b /= 5; // hetzelfde als b = b / 5; c &= 3; // hetzelfde als c = c & 3;

In de C-taal is er een onderscheid tussen de concepten ‘datatype’ en ‘type modifier’. Het gegevenstype is geheel getal en de modificator is ondertekend of niet-ondertekend. Een geheel getal met teken heeft zowel positieve als negatieve waarden, terwijl een geheel getal zonder teken alleen positieve waarden heeft. Er zijn vijf basistypen in de C-taal.

• char – karakter.

Een variabele van het type char heeft een grootte van 1 byte, de waarden zijn verschillende tekens uit de codetabel, bijvoorbeeld: 'f', ':', 'j' (wanneer ze in het programma worden geschreven, zijn ze ingesloten in enkele citaten).

• int – heel.

De grootte van een variabele van het type int is niet gedefinieerd in de C-taalstandaard. In de meeste programmeersystemen komt de grootte van een int-variabele overeen met de grootte van een heel machinewoord. In compilers voor 16-bits processors heeft een int-variabele bijvoorbeeld een grootte van 2 bytes. In dit geval kunnen de ondertekende waarden van deze variabele in het bereik van -32768 tot 32767 liggen.

• zweven – echt.

Met het float-trefwoord kunt u variabelen van het reële type definiëren. Hun waarden hebben een fractioneel deel gescheiden door een punt, bijvoorbeeld: -5,6, 31,28, enz. Reële getallen kunnen ook in drijvende-kommavorm worden geschreven, bijvoorbeeld: -1.09e+4. Het getal vóór het symbool ‘e’ wordt de mantisse genoemd, en na de ‘e’ de exponent. Een variabele van het type float neemt 32 bits geheugen in beslag. Het kan waarden aannemen in het bereik van 3.4e-38 tot 3.4e+38.

• dubbel – dubbele precisie echt;

Met het trefwoord double kunt u een reële variabele met dubbele precisie definiëren. Het neemt twee keer zoveel geheugenruimte in beslag als een float-variabele. Een variabele van het dubbele type kan waarden aannemen in het bereik van 1,7e-308 tot 1,7e+308.

• leegte – geen waarde.

Het void trefwoord wordt gebruikt om de waarde van een object te neutraliseren, bijvoorbeeld om een ​​functie te declareren die geen enkele waarde retourneert.

Variabele typen:

Programma's werken met verschillende gegevens, die eenvoudig of gestructureerd kunnen zijn. Eenvoudige gegevens zijn gehele getallen en reële getallen, symbolen en pointers (adressen van objecten in het geheugen). Gehele getallen hebben geen fractioneel deel, maar reële getallen wel. Gestructureerde gegevens zijn arrays en structuren; ze zullen hieronder worden besproken.

Een variabele is een cel in het computergeheugen die een naam heeft en een bepaalde waarde opslaat. De waarde van een variabele kan veranderen tijdens de uitvoering van het programma. Wanneer een nieuwe waarde naar een cel wordt geschreven, wordt de oude gewist.

Het is een goede stijl om variabelen betekenisvol te benoemen. De variabelenaam kan één tot 32 tekens bevatten. 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. De variabelenaam mag niet overeenkomen met gereserveerde woorden.

Typ teken

char is het meest economische type. Het char-type kan ondertekend of niet-ondertekend zijn. Aangeduid als “signed char” (ondertekend type) en “unsigned char” (niet-ondertekend type). Het ondertekende type kan waarden opslaan in het bereik -128 tot +127. Unsigned – van 0 tot 255. 1 byte geheugen (8 bits) wordt toegewezen aan een char-variabele.

De ondertekende en niet-ondertekende trefwoorden geven aan hoe de nulbit van de gedeclareerde variabele wordt geïnterpreteerd, dat wil zeggen: als het niet-ondertekende sleutelwoord is gespecificeerd, wordt de nulbit geïnterpreteerd als onderdeel van een getal, en anders wordt de nulbit geïnterpreteerd als ondertekend.

Typ int

De gehele waarde int kan kort of lang zijn. Het korte trefwoord wordt na de ondertekende of niet-ondertekende trefwoorden geplaatst. Er zijn dus typen: ondertekende korte int, niet-ondertekende korte int, ondertekende lange int, niet-ondertekende lange int.

Een variabele van het type ondertekend short 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. Aan elk van hen wordt precies twee bytes geheugen toegewezen (16 stukjes).

Bij het declareren van een variabele van het type 'signed short int' kunnen de trefwoorden 'signed' en 'short' worden weggelaten, en een dergelijk variabel type kan eenvoudigweg int worden gedeclareerd. Het is ook mogelijk om dit type met één trefwoord kort te declareren.

Een niet-ondertekende korte int-variabele kan worden gedeclareerd als een niet-ondertekende int of een niet-ondertekende short.

Voor elke ondertekende lange int- of niet-ondertekende lange int-waarde worden 4 bytes geheugen (32 bits) toegewezen. 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 van het type long long int, waarvoor 8 bytes geheugen zijn toegewezen (64 bits). Ze kunnen 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 ook eenvoudigweg worden gedeclareerd door twee lange, lange trefwoorden.

Variabelen declareren

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.

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

Modifiers – trefwoorden ondertekend, niet-ondertekend, kort, lang.
Een typespecificatie is een char- of int-trefwoord dat het type specificeert van de variabele die wordt gedeclareerd.
Identifier is de naam van de variabele.

Teken x;

int a, b, c;

niet-ondertekend lang lang y;

Wanneer een variabele wordt gedeclareerd, kan deze worden geïnitialiseerd, dat wil zeggen dat er een initiële waarde aan wordt toegewezen.

Int x = 100;

Wanneer de variabele x wordt gedeclareerd, bevat deze onmiddellijk het getal 100. Het is beter om geïnitialiseerde variabelen op afzonderlijke regels te declareren.

Gegevenstypen in C zijn een klasse gegevens waarvan de waarden vergelijkbare kenmerken hebben. Het type definieert de interne representatie van gegevens in het geheugen. De meest elementaire gegevenstypen: logische, gehele getallen, getallen met drijvende komma, strings, pointers.

Bij dynamisch typen wordt een variabele op het moment van initialisatie aan een type gekoppeld. Het blijkt dat een variabele in verschillende delen van de code verschillende typen kan hebben. Dynamisch typen wordt ondersteund door Java Script, Python, Ruby, PHP.

Statisch typen is het tegenovergestelde van dynamisch typen. Bij het declareren krijgt een variabele een type dat later niet verandert. De talen C en C++ zijn precies dat. Deze methode is het handigst voor het schrijven van complexe code, en veel fouten worden tijdens de compilatiefase geëlimineerd.

Talen zijn informeel verdeeld in sterk getypeerd en zwak getypeerd. Sterk typen betekent dat de compiler een fout genereert als de verwachte en werkelijke typen niet overeenkomen.

x = 1 + “2”; //fout - u kunt geen symbool aan een getal toevoegen

Een voorbeeld van zwak typen.

De typeconsistentiecontrole wordt uitgevoerd door het typeveiligheidssysteem. Er treedt bijvoorbeeld een typefout op als u een getal als functie probeert te gebruiken. Er zijn ongetypeerde talen. In tegenstelling tot getypte kunt u hiermee elke bewerking op elk object uitvoeren.

Geheugen lessen

• Variabelen hebben, ongeacht hun type, hun eigen reikwijdte en levensduur.
• Geheugenklassen:
• auto;
• statisch;

Alle variabelen in de C-taal zijn standaard lokaal. Ze kunnen alleen binnen een functie of blok worden gebruikt. Wanneer de functie is voltooid, wordt hun waarde vernietigd.

Een statische variabele is ook lokaal, maar kan buiten zijn blok een andere waarde hebben, en de waarde wordt tussen functieaanroepen opgeslagen.

De externe variabele is globaal. Het is beschikbaar in elk deel van de code en zelfs in een ander bestand.

Gegevenstypespecificaties in C mogen in de volgende gevallen niet worden gespecificeerd:

1. Alle variabelen binnen het blok zijn geen variabelen. Als het de bedoeling is dat deze specifieke geheugenklasse wordt gebruikt, wordt de automatische specificatie niet gespecificeerd.
2. Alle functies die buiten een blok of functie worden gedeclareerd, zijn standaard globaal, dus de externe specificatie is niet vereist.

Om eenvoudige typen aan te geven, gebruikt u de int-, char-, float- of double-specificaties. De modificatoren unsigned, Signed, Short, Long, Long Long kunnen worden vervangen door variabelen.

Standaard zijn alle getallen ondertekend; daarom kunnen ze alleen binnen het bereik van positieve getallen vallen. Om een ​​variabele van het type char als ondertekend te definiëren, schrijft u ondertekende char. Lang, lang, lang en kort geven aan hoeveel geheugenruimte is toegewezen voor opslag. De grootste is lang lang, de kleinste is kort.

Char is het kleinste gegevenstype in C. Er wordt slechts 1 byte geheugen toegewezen om waarden op te slaan. Aan een variabele van het type karakter worden meestal tekens toegewezen, en minder vaak - cijfers. Karakterwaarden staan ​​tussen aanhalingstekens.

Het int-type slaat gehele getallen op, de grootte ervan is ongedefinieerd - het neemt maximaal 4 bytes geheugen in beslag, afhankelijk van de computerarchitectuur.

Een expliciete conversie van een niet-ondertekende variabele wordt als volgt gespecificeerd:

De impliciete ziet er als volgt uit:

Zweven en dubbel definiëren van getallen met een punt. Zwevende getallen worden weergegeven als -2,3 of 3,34. Dubbel wordt gebruikt voor grotere precisie - er worden meer cijfers aangegeven na het scheidingsteken voor gehele getallen en breuken. Dit type neemt meer geheugenruimte in beslag dan float.

Void heeft een lege waarde. Het definieert functies die niets retourneren. Deze specificatie specificeert een lege waarde in methodeargumenten. Pointers, die elk gegevenstype kunnen accepteren, worden ook als ongeldig gedefinieerd.

Booleaans type Bool

Gebruikt in conditietests en lussen. Heeft slechts twee betekenissen:

• WAAR;
• leugen.

Booleaanse waarden kunnen worden geconverteerd naar een int-waarde. Waar is gelijk aan één, onwaar is gelijk aan nul. Typeconversie is alleen mogelijk tussen bool en int, anders geeft de compiler een foutmelding.

if (x) ( // Fout: "Kan type 'int' niet impliciet converteren naar 'bool'"

if (x != 0) // Op de C#-manier

Tekenreeksen en arrays

Arrays zijn complexe gegevenstypen in C. PL werkt niet op dezelfde manier met strings als Javascript of Ruby. In C zijn alle strings arrays van elementen met een tekenwaarde. Regels eindigen met een null-byte “

Programmeur zegt:

Hallo! Ik heb je artikel gelezen. Ik was heel verdrietig en grappig tegelijk. Vooral deze zin van je is moordend: “Aangezien een variabele van het type char vaak als array wordt gebruikt, wordt het aantal mogelijke waarden bepaald.” 😆 😆 😆
Ik lach je niet uit. Een website maken is echt een prestatie. Ik wil u alleen met advies ondersteunen en u op een paar fouten wijzen.

1. De waarde van een variabele van het type char wordt als volgt toegewezen:

Hier is het:

Char a = *"A";

De pointer naar de array wordt gedeadresseerd en als resultaat wordt de waarde van het eerste element van de array geretourneerd, d.w.z. 'A'

2. Het resetten gaat als volgt:

Char a = NULL;
teken b = ();

//En dit is hoe de regel in de hoofdtekst van het programma wordt gewist

"" - dit symbool wordt een nulterminator genoemd. Het wordt aan het einde van de regel geplaatst. Je hebt zelf, zonder het te weten, de s1-array uit je artikel gevuld met dit symbool. Maar het was mogelijk om dit symbool alleen aan het nulelement van de array toe te wijzen.

3. Voel je vrij om terminologie te gebruiken.
Het =-teken is een toewijzingsbewerking.
Het *-teken is een de-adresseringsbewerking.
Ik bedoel dit fragment van het artikel: “Alles bleek zo eenvoudig, vóór het =-teken moest je een *-teken plaatsen en moest je het elementnummer opgeven (nul komt overeen met de eerste)”

Begrijp me niet verkeerd, het artikel kan niet bestaan ​​in zijn huidige vorm. Wees niet lui, herschrijf het.
Je hebt een grote verantwoordelijkheid! Ik meen het. De pagina's van uw site zijn opgenomen in de eerste pagina met Yandex-resultaten. Veel mensen zijn al begonnen je fouten te herhalen.

Succes! Je kunt het!

:
Ik weet dit al heel lang, het is gewoon moeilijk om voortdurend 200 artikelen te herlezen om iets te corrigeren. En sommige onbeschofte types schrijven zo dat ze, zelfs als ze weten wat het beste is om te corrigeren, helemaal niet bereid zijn om het te corrigeren.

Andere fouten corrigeer ik graag. corrigeer eventuele onnauwkeurigheden als deze voorkomen. Ik waardeer je hulp. bedankt. Ik weet dit al heel lang, het is gewoon moeilijk om 200 artikelen voortdurend opnieuw te lezen om iets te corrigeren. En sommige onbeschofte types schrijven zo dat ze, zelfs als ze weten wat het beste is om te corrigeren, helemaal niet bereid zijn om het te corrigeren.
Met je char b = (); Dit is helemaal geen nulstelling. Ze zouden het op zijn minst moeten onderzoeken.
als we het hebben over het nulteken "" ; Toen ik de regel ermee vulde, wist ik heel goed dat het doel was om echte reiniging te laten zien, en niet iets dat zichtbaar is voor het oog, omdat de regel rommel bevat, die soms in de weg zit. Je moet zelf voorzichtiger zijn met de termen, "null-beëindigingssymbool" of gewoon "nul-symbool", geen terminator))) En het terminator-symbool klinkt gewoon cool.

Ik zal het artikel moderniseren, maar ik zal niet overstappen naar de stijl van iemand anders. Als ik denk dat het voor een beginner gemakkelijker is om het op deze manier te begrijpen dan op de manier die hij/zij wil, dan laat ik het zo. Begrijp mij ook niet verkeerd. Het woord ‘teken’ is voor een zwakke beginner veel gemakkelijker te begrijpen en te onthouden dan de definitie en naam van elk teken. Er is helemaal geen sprake van een vergissing, het is een teken, een teken. Minder nadruk op het ene geeft meer nadruk op het andere.

Andere fouten corrigeer ik graag. corrigeer eventuele onnauwkeurigheden als deze voorkomen. Ik waardeer je hulp. Bedankt.

Hallo nogmaals!
Ik wil het verduidelijken. De term “zero-terminator” (terminator van de Engelse limiter) werd gebruikt door mijn leraar aan de universiteit. Blijkbaar is dit ouderwets!
Wat betreft het opnieuw instellen van rijen.
teken b = (); Dit is echt een reset. De hele array is gevuld met nullen. Als je me niet gelooft, kijk dan eens!
Als we een regel in zijn natuurlijke, alledaagse betekenis beschouwen, dan is een ‘lege’ regel een regel waarin geen enkel teken voorkomt. Daarom is het in 99,9% van de gevallen voldoende om een ​​nulteken aan het begin te plaatsen. Normaal gesproken wordt een string verwerkt tot aan het eerste nulteken, en welke tekens erna komen is niet langer belangrijk. Ik begrijp dat je de lijn wilde resetten. Ik heb zojuist besloten een beproefde klassieke optie aan te bieden.

:
Wanneer “Gewoonlijk gaat de tekenreeksverwerking naar het eerste null-teken en welke tekens daarna komen, is niet langer belangrijk” - ja, de tekenreeks is nul
Als we kijken naar "echte nulstelling van alle cellen van een rij (waarover ik schreef)" - nee, geen nulstelling, en zelfs het eerste teken is niet nul. Ik heb deze optie aangevinkt. MinGW(CodeBlock) - de hele array geeft het teken "a"
Ik denk niet dat dit een reden tot discussie is.

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 toont de belangrijkste gegevenstypen in C++. De gehele tabel is verdeeld in drie kolommen. De eerste kolom geeft een gereserveerd woord aan, dat ieder zijn eigen gegevenstype zal 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 van 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 de logische expressie waar is, 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; // variabele van het type bool genaamd boolean if (boolean) // voorwaarde van de if cout-operator<< "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 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 (American Standard Code for Information Interchange) is een 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 symbol = "a"; // een variabele van het type char declareren 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 11heeft een stringarray gedeclareerd 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 zijn alle bereiken van geaccepteerde waarden en groottes van bezet geheugen genomen 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 datatypen met negatieve en positieve getallen // waarbij b het aantal bytes is dat in het geheugen is toegewezen voor een variabele met dit datatype // 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