Het variabele type is dubbel c. C-gegevenstypen

Een gegevenstype in programmeren is een verzameling van twee sets: een set waarden en een set bewerkingen die daarop kunnen worden toegepast. U kunt bijvoorbeeld de bewerkingen optellen (+), vermenigvuldigen (*), integer delen (/), rest (%), en aftrekken (-) toepassen op het gegevenstype van niet-negatieve gehele getallen bestaande uit een eindige verzameling van natuurlijke getallen.

Een programmeertaal heeft meestal een reeks primitieve gegevenstypen - typen die door een programmeertaal worden geleverd als een standaard ingebouwde eenheid. In C++ worden dergelijke typen door de taalmaker fundamentele typen genoemd. Fundamentele typen in C++ zijn:

• logisch (bool);
• teken (bijv. char);
• geheel getal (bijv. int);
• drijvende komma (bijv. float);
• opsommingen (gedefinieerd door de programmeur);
• leegte.

De volgende typen zijn bovenop de genoemde gebouwd:

• indicatief (bijv. int *);
• arrays (bijv. char);
• referentie (bijv. dubbele &);
• andere structuren.

Laten we verder gaan met het begrip letterlijke (bijvoorbeeld 1, 2.4F, 25e-4, 'a', enz.): een letterlijke is een vermelding in de broncode van een programma met een vaste waarde. Met andere woorden, een letterlijke is gewoon een afbeelding van een object (waarde) van een bepaald type in de programmacode. C ++ heeft de mogelijkheid om integer-waarden, floating point-waarden, karakters, boolean, strings te schrijven.

Een integer letterlijke kan worden geschreven in:

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

24, 030, 0x18 zijn allemaal records van hetzelfde nummer in verschillende nummersystemen.
Om getallen met drijvende komma te schrijven, schrijf je door een punt: 0.1, .5, 4. - ofwel in
exponentiële notatie - 25e-100. Er mogen geen spaties in zo'n item staan.

De naam waarmee we de waarden geschreven door letterlijke waarden kunnen binden, wordt een variabele genoemd. Een variabele is een benoemd of anderszins geadresseerd 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 heeft u op elk moment toegang tot gegevens en kunt u deze zo nodig wijzigen. De gegevens die door de naam van een variabele kunnen worden verkregen, worden de waarde van de variabele genoemd.
Om een ​​variabele in een programma te gebruiken, moet deze worden gedeclareerd en indien nodig kunt u deze definiëren (= initialiseren). Een variabele declaratie in de programmatekst bevat noodzakelijkerwijs 2 delen: het basistype en de declarator. De specificatie en initialisatie zijn optionele onderdelen:

Const int voorbeeld = 3; // hier const - specificatie // int - basistype // voorbeeld - variabelenaam // = 3 - initialisatie.

De variabelenaam is een reeks tekens uit het Latijnse alfabet (kleine letters en hoofdletters), cijfers en/of het 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 er wordt opgeslagen, bijvoorbeeld "maandBetaling". In de synopsis en in de praktijk zullen we de CamelCase-notatie gebruiken voor de regels voor het schrijven van variabelen. De naam van een variabele kan niet samenvallen met woorden die in de taal zijn gereserveerd, voorbeelden van dergelijke woorden: if, while, function, goto, switch, etc.

De declarator kan, naast de variabelenaam, extra tekens bevatten:

• * - aanwijzer; voor de naam;
• * const - constante aanwijzer; voor de naam;
• & - koppeling; voor de naam;
• - reeks; achter de naam;
• () - functie; achter de naam.

Met de initialisator kunt u de waarde voor een variabele direct na de declaratie definiëren. De initialisatie begint met een letterlijke gelijkheid (=) en vervolgens vindt het proces van het instellen van de waarde van de variabele plaats. Over het algemeen duidt het gelijkteken in C++ op een toewijzingsbewerking; met zijn hulp kunt u de waarde van een variabele instellen en wijzigen. Het kan voor verschillende soorten anders zijn.

De specificatie specificeert andere kenmerken dan het type. Met de const-specificatie die in het voorbeeld wordt getoond, kunt u de daaropvolgende wijziging van de waarde van de variabele verbieden. Dergelijke onveranderlijke variabelen worden constant of constant genoemd.

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

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

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

Basisgegevenstypen in C ++

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

1. Integer type (char, short (int), int, long (int), long long)

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

• 2 8N = 2 8 * 1 = 256, waarbij N de geheugengrootte in bytes is voor het opslaan van de waarde

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

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

Standaard wordt een integer-variabele als ondertekend beschouwd. Om in de code aan te geven dat de variabele unsigned moet zijn, wordt aan het basistype links een teken van teken toegekend, d.w.z. niet ondertekend:

Niet-ondertekende lange waarden; // specificeert een integer (lang) unsigned type.

De vermelde typen verschillen alleen in de grootte van het geheugen dat nodig is voor opslag. Aangezien de C++-taal een redelijk machine-afhankelijke taalstandaard is, garandeert deze alleen dat aan de volgende voorwaarde wordt voldaan:

• 1 = char maat ≤ korte maat ≤ int maat ≤ lange maat.

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

U kunt rekenkundige bewerkingen uitvoeren met waarden van een geheel getal: +, -, *, /,%; vergelijkingsbewerkingen: ==,! =,<=, <, >,> =; bitsgewijze bewerkingen: &, |, 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 bereik zijn; in dit geval zal het programma een fout genereren.
Integer-deling (/) vindt het gehele deel wanneer een geheel getal wordt gedeeld door een ander. Bijvoorbeeld:

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

Het procentsymbool (%) 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: & (AND), | (OF), xor (exclusief OF),<< (побитовый сдвиг влево), >> (bitsgewijze naar rechts schuiven).

Bitsgewijze bewerkingen AND, OR en XOR passen de bijbehorende logische bewerking toe op elk bit informatie:

• 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 x of 3 10 = 01 2 x of 11 2 = 10 2

Bij beeldverwerking worden 3 kanalen gebruikt voor kleur: rood, blauw en groen - plus transparantie, die worden opgeslagen in een variabele van het type int, aangezien elk kanaal heeft een reeks waarden van 0 tot 255. In hexadecimale notatie wordt een 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 een ​​bepaald kanaal uit zo'n geheel getal te selecteren, gebruikt u de zogenaamde. masker, waarbij de voor ons interessante posities F 16 of 1 2 zijn. Dat wil zeggen, om de waarde van het blauwe kanaal te markeren, moet u een masker gebruiken, d.w.z. bitsgewijze EN:

Int blue_channel = 0x180013FF & 0x00FF0000;

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

Bitsgewijze verschuiving verschuift naar links of rechts met zoveel binaire cijfers van het getal als aangegeven aan de rechterkant van de bewerking. Het getal 39 voor het char-type in binair wordt bijvoorbeeld in de volgende vorm geschreven: 00100111. Dan:

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

Als de variabele van het type zonder teken is, is het resultaat 156, voor ondertekend is het -100. Merk op dat voor getekende integer-types die in de meest significante bit van de bitrepresentatie een teken is dat het getal negatief is. In dit geval komt de waarde in binaire vorm bestaande uit alle enen overeen met -1; als 1 alleen in het meest significante bit zit, en in de overige bits zijn er nullen, dan heeft zo'n getal de minimumwaarde voor een bepaald type: voor char is het -128.

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

De reeks drijvende-kommawaarden is een subset van reële getallen, maar niet elk reëel getal is binair weer te geven, wat soms tot domme fouten leidt:

Vlotterwaarde = 0,2; waarde == 0,2; // fout, waarde zal hier geen 0.2 zijn.

Bij het werken met variabelen met drijvende komma moet de programmeur niet de bewerking van het controleren op gelijkheid of ongelijkheid gebruiken, in plaats daarvan gebruiken ze meestal het controleren voor het bereiken van een bepaald interval:

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

Naast vergelijkingsbewerkingen ondersteunt het type drijvende komma 4 rekenkundige bewerkingen, die volledig overeenkomen met wiskundige bewerkingen met reële getallen.

3. Booleaans (logisch) type (bool)

Bestaat uit slechts twee waarden: waar en onwaar. Booleaanse bewerkingen worden gebruikt om met variabelen van dit type te werken:! (NIET), == (gelijkheid),! = (Ongelijkheid), && (logische AND), || (logische OF). Het resultaat van elke bewerking is te vinden in de bijbehorende waarheidstabel. bijvoorbeeld:

4. Karaktertype (char, wchar_t)

Het char-type is niet alleen een integer-type (meestal wordt dit type byte genoemd), maar ook een tekentype dat het nummer van een teken uit de tabel opslaat met behulp van een ASCII-teken. De code 0x41 komt bijvoorbeeld overeen met het teken 'A' en 0x71 komt overeen met 't'.

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

5.1. arrays

Met arrays kunt u een opeenvolgende set elementen van hetzelfde type opslaan. Een array wordt in het geheugen opgeslagen in een aangrenzend blok, dus u kunt een array niet declareren zonder de grootte ervan op te geven. Om een ​​array te declareren, schrijft u na de naam van de variabele vierkante haken () om de grootte aan te geven. Bijvoorbeeld:

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

Om een ​​array te initialiseren, worden waarden tussen accolades weergegeven. U kunt op deze manier alleen initialiseren tijdens de declaratie van een variabele. 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 (een array-element), gebruikt u de indextoegangsbewerking () door het elementnummer op te geven (nummers beginnen bij 0). Bijvoorbeeld:

Kansen; // toegang tot het eerste element van de array. Geeft 1 kansen terug; // toegang tot het derde element. Retourneert de waarde 7 odds = 13; // Het 5e element van de array krijgt een nieuwe oddswaarde toegewezen; // 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 einde-van-regelteken '\ 0'. Deze speciale tekens, bestaande uit een backslash en een identificerend teken, worden controle- of escapetekens genoemd. Er zijn bijvoorbeeld ook '\ n' - het begin van een nieuwe regel, '\ t' - tabel. Om in de backslash-regel te schrijven, wordt escaping gebruikt - er wordt nog een schuine streep voor het teken zelf geplaatst: '\'. Ontsnappen wordt ook gebruikt voor aanhalingstekens.

Laten we een stringvariabele maken:

Char textExample = (‘T’, ‘e’, ‘s’, ‘t’, ‘\ 0’); // geschreven string "Test"

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, is hier nog een ander nuttig gegevenstype - string. Snaren
dit type kan bijvoorbeeld toevoegen:

String hallo = "Hallo,"; stringnaam = "Max!"; string hallo_name = hallo + naam; // Het resultaat is de string "Hi, Max!"

6. Koppeling

Int a = 2; // de variabele "a" wijst naar de waarde 2 int & b = a; // variabele "b" wijst naar dezelfde plaats als "a" b = 4; // verandert de waarde van b, de programmeur verandert de waarde van a. Nu a = 4 int & c = 4; // fout, je kunt dat niet doen, omdat aan de link kan geen waarde worden toegekend

7. Index

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

Adressen 0x0 betekent dat de aanwijzer leeg is, d.w.z. geeft geen gegevens aan. Dit adres heeft zijn eigen letterlijke - NULL:

Int * nullPtr = NULL; // nul punten

Het optellen en aftrekken van een adres met een geheel getal of een ander adres maakt het mogelijk
blader door het geheugen dat beschikbaar is voor het programma.

De bewerking van het ophalen van gegevens die begint bij het adres dat in de aanwijzer is opgeslagen, wordt dereferentie genoemd (*). Het programma leest het vereiste aantal geheugencellen en retourneert de waarde die in het geheugen is opgeslagen.

Int-waardeInMemory = 2; // stel een variabele van het type integer int * somePtr = // kopieer het adres van de variabele, hier & - geeft het adres van de variabele somePtr terug; // adres van een geheugenlocatie, bijvoorbeeld 0x2F * somePtr; // de waarde wordt opgeslagen in 4 cellen: 0x2F, 0x30, 0x31 en 0x32

Een toewijzingsbewerking is niet beschikbaar voor pointers, wat syntactisch hetzelfde is als de kopieerbewerking. 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 opgeslagen in het geheugen, net als de waarden van variabelen van andere typen, en duurt 4 bytes, zodat u een aanwijzer naar een aanwijzer kunt maken.

8. Opsommingen

Opsommingen zijn het enige basistype dat door de programmeur wordt gespecificeerd. Over het algemeen is een opsomming een geordende set van benoemde integer-constanten, waarbij de naam van de opsomming het basistype is.

Enum kleur (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 (LEZEN = 1, SCHRIJVEN = 2, EXEC = 4);

Het is vaak handig om opsommingen te gebruiken waarvan de waarden machten van twee zijn, aangezien in binaire weergave bestaat een getal dat een macht van 2 is uit 1 en nullen. Bijvoorbeeld:

8 10 = 00001000 2

Het resultaat van het bij elkaar optellen van deze getallen geeft altijd eenduidig ​​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 lege type tot de fundamentele typen, maar het kan alleen worden gebruikt als onderdeel van meer complexe typen, aangezien er zijn geen lege objecten. Meestal wordt dit type gebruikt om te informeren dat een functie geen retourwaarde heeft, of als het basistype van een aanwijzer 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 aanwijzer op naar een onbekend type

Vaak gebruiken we void precies om aan te geven dat de functie geen waarde retourneert. Ze werken met een lege aanwijzer wanneer de programmeur de volledige verantwoordelijkheid op zich neemt voor de geheugenintegriteit en correcte typeconversie.

Gips

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

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

De conversie van het omgekeerde type wordt uitgevoerd met verlies van informatie, dus alleen het gehele deel van het drijvende-kommagetal blijft over, het fractionele deel gaat verloren.

Er is de mogelijkheid om typen expliciet te converteren, hiervoor schrijf je links van de variabele of een waarde van het oorspronkelijke type tussen haakjes het type waarnaar de conversie zal worden uitgevoerd:

Int-waarde = (int) 2,5;

Unaire en binaire bewerkingen

De bewerkingen die we eerder hebben uitgevoerd, worden binair genoemd: links en rechts van het bewerkingssymbool staan ​​waarden of variabelen, bijvoorbeeld 2 + 3. In programmeertalen gebruiken ze naast binaire bewerkingen ook unaire bewerkingen die op variabelen worden toegepast. Ze zijn zowel links als rechts van de variabele te vinden, verschillende van dergelijke bewerkingen zijn eerder tegengekomen - de dereferentie (*) en het nemen van het adres van de variabele (&) zijn unair. De operatoren "++" en "-" verhogen en verlagen de waarde van een integer-variabele met respectievelijk 1, en kunnen zowel links als rechts van de variabele worden geschreven.

C ++ gebruikt ook een verkorte notatie van binaire bewerkingen in het geval dat het linker- en rechtergedeelte van de uitdrukking dezelfde variabele bevatten, d.w.z. een bewerking wordt uitgevoerd met 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 deze sectie gaan we in op de basisgegevenstypen in C++, deze gegevenstypen worden ook wel ingebouwde gegevenstypen genoemd. De programmeertaal C++ is een uitbreidbare programmeertaal. Uitbreidbaar betekent dat u naast ingebouwde gegevenstypen ook uw eigen gegevenstypen kunt maken. Daarom zijn er een groot aantal gegevenstypen in C ++. We zullen alleen de belangrijkste bestuderen.

Tabel 1 toont de basisgegevenstypen in C++. De hele tabel is verdeeld in drie kolommen. De eerste kolom geeft een gereserveerd woord aan dat elk zijn eigen gegevenstype zal definiëren. 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 geldige waarden. Merk op dat in de tabel alle gegevenstypen zijn gesorteerd van klein naar groot.

Bool-gegevenstype

De eerste in de tabel is het datatype bool — een integer gegevenstype, aangezien het bereik van geldige waarden gehele getallen zijn van 0 tot 255. Maar zoals je al hebt opgemerkt, is het tussen haakjes geschreven - een booleaans gegevenstype, en dit is ook waar. Omdat bool uitsluitend gebruikt voor het opslaan van de resultaten van booleaanse expressies. Een Booleaanse expressie kan een van de twee resultaten hebben, waar of onwaar. waar - als de booleaanse uitdrukking waar is, onwaar - als de booleaanse uitdrukking onwaar is.

Maar aangezien het bereik van geldige waarden van het bool-gegevenstype van 0 tot 255 is, was het nodig om dit bereik op de een of andere manier te correleren met de booleaanse constanten waar en onwaar die in de programmeertaal zijn gedefinieerd. De constante waar is dus gelijk aan alle getallen van 1 tot en met 255, terwijl de constante onwaar gelijk is aan slechts één geheel getal - 0. Overweeg een programma dat het gegevenstype bool gebruikt.

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

V lijn 9een variabele van het type wordt gedeclareerd bool die is geïnitialiseerd op 25. In theorie nalijn 9, in booleaanse variabele het 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 komt erop neer dat in een variabele zoals bool kan twee waarden bevatten - 0 (false) of 1 (true). Terwijl onder het gegevenstype bool een hele byte wordt toegewezen, wat betekent dat een variabele van het type bool kan getallen van 0 tot 255 bevatten. Om valse en echte waarden te bepalen, zijn slechts twee waarden nodig, 0 en 1. De vraag rijst: "Waar zijn de andere 253 waarden voor?"

Op basis van deze situatie zijn we overeengekomen om de getallen van 2 tot 255 te gebruiken als equivalent aan het getal 1, dat wil zeggen, waar. Dit is de reden waarom de booleaanse variabele het getal 25 bevat en niet 1. In lijnen 10 -13 gedeclareerd die de controle overdraagt ​​aan de operator in lijn 11, als de voorwaarde waar is, en de operator in lijn 13 als de voorwaarde onwaar is. Het resultaat van het programma is weergegeven in figuur 1.

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

Afbeelding 1 - Bool-gegevenstype

Char-gegevenstype

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

ASCII (van de Engelse American Standard Code for Information Interchange) is de Amerikaanse standaardcode voor informatie-uitwisseling.

Overweeg een programma dat het gegevenstype char gebruikt.

//symbolen.cpp: definieert het ingangspunt voor de consoletoepassing. #include "stdafx.h" #include namespace std; gebruiken; int main (int argc, char * argv) (char symbol = "a"; // declareren van een variabele van het type 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 met de naam wordt gedeclareerd symbool , het krijgt de waarde van het symbool"een" ( ASCII-code). V lijn 10 cout-operator drukt het teken in de variabele af symbool. V lijn 11verklaarde een tekenreeksarray met de naam snaar , en de grootte van de array wordt impliciet ingesteld. De tekenreeks wordt opgeslagen in de tekenreeksarray"site" ... Merk op dat toen we het symbool opsloegen in een variabele zoals char , dan 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 een normaal teken worden strings uitgevoerd met de operator schat, lijn 12... Het resultaat van het programma is weergegeven in figuur 2.

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

Figuur 2 - Gegevenstype char

Gegevenstypen voor geheel getal

Integer-gegevenstypen worden gebruikt om getallen weer te geven. Tabel 1 bevat er zes: short int, unsigned short int, int, unsigned int, long int, unsigned long int . Ze hebben allemaal hun eigen grootte van bezet geheugen en bereik van geaccepteerde waarden. Afhankelijk van de compiler kunnen de grootte van het bezette geheugen en het bereik van geaccepteerde waarden variëren. In Tabel 1 zijn alle reeksen 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, op de een of andere manier, hangt af van de grootte van het bezette geheugen. Dienovereenkomstig, 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 voorvoegsel unsigned - unsigned. Het unsigned prefix betekent dat het datatype geen getekende waarden kan opslaan, dan wordt het bereik van positieve waarden verdubbeld, bijvoorbeeld de datatypes short int en unsigned short int.

Voorvoegsels van geheel getal gegevenstype:

kort — het voorvoegsel verkort het gegevenstype waarop het wordt toegepast door de grootte van het bezette geheugen te verkleinen;

lang — het voorvoegsel verlengt het gegevenstype waarop het wordt toegepast door de omvang van het bezette geheugen te vergroten;

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

Dus, in wezen hebben we één integer type voor het representeren van gehele getallen - dit is het int datatype. Dankzij de korte, lange, niet-ondertekende voorvoegsels verschijnt een bepaalde verscheidenheid aan int-gegevenstypen, die verschillen in de grootte van het bezette geheugen en (of) het bereik van geaccepteerde waarden.

Gegevenstypen met drijvende komma

Er zijn twee gegevenstypen met drijvende komma in C ++: zwevend en dubbel. Gegevenstypen met drijvende komma zijn ontworpen om getallen met drijvende komma op te slaan. De gegevenstypen zwevend en dubbel kunnen zowel positieve als negatieve getallen met drijvende komma opslaan. Het datatype float heeft twee keer minder geheugengrootte dan het dubbele datatype, wat betekent dat het bereik van geaccepteerde waarden ook kleiner is. Als het float-gegevenstype wordt gedeclareerd met het lange voorvoegsel, wordt het bereik van geaccepteerde waarden gelijk aan het bereik van geaccepteerde waarden van het dubbele gegevenstype. In principe zijn gegevenstypen met drijvende komma nodig om problemen met hoge rekennauwkeurigheid op te lossen, bijvoorbeeld geldtransacties.

We hebben dus de belangrijkste punten met betrekking tot de basisgegevenstypen in C ++ behandeld. Het blijft alleen om te laten zien waar al deze reeksen van geaccepteerde waarden en de grootte van het bezette geheugen vandaan kwamen. En hiervoor zullen we een programma ontwikkelen dat de belangrijkste kenmerken van alle hierboven besproken gegevenstypen berekent.

// data_types.cpp: definieert het toegangspunt voor de consoletoepassing. #include "stdafx.h" #include // I / O-manipulatiebibliotheek #include // headerbestand voor wiskundige functies #include namespace 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 zo opgezet dat u de kenmerken van gegevenstypen in uw systeem kunt bekijken. Het is niet de moeite waard om de code te begrijpen, omdat het programma besturingsoperators gebruikt die u waarschijnlijk nog niet kent. Voor een oppervlakkige kennismaking met de programmacode zal ik hieronder enkele punten toelichten. Operator De grootte van () berekent het aantal toegewezen bytes voor een gegevenstype of variabele. Functie pow (x, y) verhoogt de betekenis x tot de macht van y , deze functie is beschikbaar in het headerbestand ... De vaste en ingestelde precisie () manipulatoren beschikbaar via headerbestand ... De eerste is opgelost , stuurt waarden in vaste vorm naar de uitvoerstroom. Manipulator setprecision (n) geeft n . weer decimalen. De maximale waarde van een bepaald gegevenstype wordt berekend met 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 aan een variabele met dit gegevenstype // vermenigvuldigen met 8, aangezien er 8 bits in één byte zitten // 1 tussen haakjes aftrekken , aangezien de bereiknummers moeten worden gehalveerd voor positieve en negatieve waarden // aan het einde 1 aftrekken, aangezien het bereik van getallen begint bij nul // gegevenstypen met het voorvoegsel niet-ondertekend max_val_type = 2 ^ (b * 8) - 1 ; // alleen voor gegevenstypen met positieve getallen

Een voorbeeld van hoe het programma werkt, is te zien in figuur 3. De eerste kolom toont de basisgegevenstypen in C ++, de tweede kolom toont de geheugengrootte die is toegewezen aan elk gegevenstype en de derde kolom toont de maximale waarde die de overeenkomstige gegevenstype kan bevatten. De minimumwaarde wordt op dezelfde manier gevonden als de maximumwaarde. Voor gegevenstypen waarvan het voorvoegsel niet is ondertekend, is de minimumwaarde 0.

Gegevenstype byte max 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,00 unsigned long int = 4 4294967295.00 float = 4 2147483647.00 double = 8 9223372036854775808.00 Druk op een willekeurige toets om door te gaan. ... ...

Figuur 3 - C++ datatypes

Als bijvoorbeeld een variabele van het type short int de waarde 33000 krijgt, 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 wordt opgeslagen in een variabele van het type short int, zal deze hoogstwaarschijnlijk negatief zijn. Aangezien we het gegevenstype int hebben aangeroerd, is het vermeldenswaard dat u het sleutelwoord int kunt weglaten en bijvoorbeeld gewoon kort kunt schrijven. De compiler interpreteert deze notatie als short int. Hetzelfde geldt voor de lange en niet-ondertekende voorvoegsels. Bijvoorbeeld:

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

Gegevenstypen

Gegevenstypen hebben een speciale betekenis in C # omdat het een sterk getypeerde taal is. Dit betekent dat alle bewerkingen onderworpen zijn aan strikte typeovereenkomst door de compiler, en ongeldige bewerkingen worden niet gecompileerd. Daarom helpt sterke typecontrole om fouten te elimineren en de betrouwbaarheid van programma's te verbeteren. Voor typecontrole moeten alle variabelen, uitdrukkingen en waarden van een specifiek type zijn. Er bestaat helemaal niet zoiets als een "typeloze" variabele in deze programmeertaal. Bovendien bepaalt het type van de waarde welke bewerkingen erop mogen worden uitgevoerd. Een bewerking die voor het ene gegevenstype is toegestaan, is mogelijk niet geldig voor een ander.

Er zijn twee algemene categorieën van ingebouwde gegevenstypen in C #: waarde typen en referentietypes... Ze verschillen in de inhoud van de variabele. Conceptueel is het verschil tussen beide dat een waardetype gegevens rechtstreeks opslaat, terwijl een referentietype een verwijzing naar een waarde opslaat.

Deze typen worden op verschillende plaatsen in het geheugen opgeslagen: waardetypen worden opgeslagen in een gebied dat bekend staat als de stapel, en referentietypen in een gebied dat de beheerde heap wordt genoemd.

Laten we kijken waarde soorten.

Integer typen

C # definieert negen integer-typen: char, byte, sbyte, kort, ushort, int, uint, lang en ulong... Maar het char-type wordt voornamelijk gebruikt om tekens weer te geven en wordt daarom afzonderlijk beschouwd. De andere acht integer-typen zijn voor numerieke berekeningen. Hun weergavebereik van getallen en bitdiepte worden hieronder weergegeven:

Zoals u in de bovenstaande tabel kunt zien, definieert C # beide varianten van de verschillende typen gehele getallen, ondertekend en niet-ondertekend. Ondertekende integer-typen verschillen van niet-ondertekende tegenhangers in de manier waarop ze het meest significante bit van een geheel getal interpreteren. Als bijvoorbeeld een getekende integer-waarde is opgegeven in een programma, genereert de C#-compiler code die de meest significante bit van het integer als tekenvlag gebruikt. Een getal wordt als positief beschouwd als de tekenvlag 0 is en als negatief als het 1 is.

Negatieve getallen worden bijna altijd weergegeven door de twee-complementmethode, waarbij alle binaire cijfers van een negatief getal eerst worden omgekeerd en vervolgens 1 bij dat getal wordt opgeteld.

Waarschijnlijk het meest voorkomende type geheel getal bij het programmeren is: int-type... Variabelen van het type int worden vaak gebruikt voor lusbesturing, array-indexering en algemene wiskundige berekeningen. Wanneer een integerwaarde met een groter bereik van getalweergave vereist is dan die van het int-type, zijn er een aantal andere integer-typen beschikbaar voor dit doel.

Dus als de waarde ongetekend moet worden opgeslagen, kunt u ervoor kiezen: uint-type, voor grote ondertekende waarden - lang type, en voor grote niet-ondertekende waarden, het type ulong... Als voorbeeld staat hieronder een programma dat de afstand van de aarde tot de zon in centimeters berekent. Om zo'n grote waarde op te slaan, gebruikt het een variabele van het lange type:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; namespace ConsoleApplication1 (klasse Programma (static void Main (string args) (lang resultaat; const long km = 149800000; // afstand in km.result = km * 1000 * 100; Console.WriteLine (resultaat); Console.ReadLine (); )))

Aan alle integer-variabelen kan een decimale of hexadecimale notatie worden toegewezen. In het laatste geval is het 0x-voorvoegsel vereist:

Lange x = 0x12ab;

Als er enige onzekerheid bestaat of een geheel getal van het type int, uint, long of ulong is, dan standaard een int wordt geaccepteerd. Om expliciet aan te geven welk ander integer type een waarde moet hebben, kun je de volgende tekens aan het getal toevoegen:

Uint ui = 1234U; lang l = 1234L; ulong ul = 1234UL;

U en L kunnen ook in kleine letters worden geschreven, hoewel kleine letters L gemakkelijk kunnen worden verward met 1 (één).

Typen met drijvende komma

Met typen met drijvende komma kunt u getallen weergeven met een breuk. Er zijn twee soorten gegevenstypen met drijvende komma in C #: vlot en dubbele... Ze vertegenwoordigen respectievelijk enkele precisie en dubbele precisie numerieke waarden. De capaciteit van het float-type is dus 32 bits, wat ongeveer overeenkomt met het weergavebereik van getallen van 5E-45 tot 3.4E + 38. En de bitdiepte van het dubbele type is 64 bits, wat ongeveer overeenkomt met het weergavebereik van getallen van 5E-324 tot 1.7E + 308.

Het float-gegevenstype is voor kleinere drijvende-kommawaarden die minder precisie vereisen. Het dubbele datatype is groter dan float en biedt een hogere mate van precisie (15 bits).

Als een niet-gehele waarde hard gecodeerd is in de broncode (bijvoorbeeld 12.3), gaat de compiler er gewoonlijk van uit dat een dubbele waarde wordt geïmpliceerd. Als de waarde moet worden opgegeven als een float, moet u er een F (of f) aan toevoegen:

Vlotter f = 12,3F;

Decimaal gegevenstype

Er is ook een decimaal type beschikbaar om zeer nauwkeurige getallen met drijvende komma weer te geven. decimale, die bedoeld is voor gebruik in financiële berekeningen. Dit type is 128 bits breed om numerieke waarden weer te geven variërend van 1E-28 tot 7.9E + 28. U weet waarschijnlijk dat fouten bij het afronden van decimalen veel voorkomen in gewone rekenkunde met drijvende komma. Deze fouten worden geëlimineerd door het decimale type te gebruiken, dat getallen tot 28 (en soms 29) decimalen kan vertegenwoordigen. Omdat dit gegevenstype decimale waarden kan weergeven zonder afrondingsfouten, is het vooral handig voor financiële berekeningen:

Systeem gebruiken; met behulp van System.Collections.Generic; met behulp van System.Linq; met behulp van System.Text; namespace ConsoleApplication1 (klasse Programma (static void Main (string args) (// *** Berekening van de kosten van kapitaalinvesteringen met *** // *** vast rendement *** decimaal geld, procent; int i; const byte jaar = 15; geld = 1000,0m; procent = 0,045m; for (i = 1; i

Het resultaat van dit programma is:

symbolen

In C # worden tekens niet weergegeven door 8-bits code, zoals in veel andere programmeertalen, zoals C ++, maar door 16-bits code genaamd unicode... De tekenset van Unicode is zo breed dat het tekens uit bijna elke natuurlijke taal ter wereld omvat. Terwijl veel natuurlijke talen, waaronder Engels, Frans en Duits, worden gekenmerkt door relatief kleine alfabetten, gebruiken een aantal andere talen, zoals Chinees, vrij uitgebreide tekensets die niet kunnen worden weergegeven door een 8-bits code. Om deze beperking te overwinnen, definieert C # tekentype staat voor niet-ondertekende 16-bits waarden variërend van 0 tot 65535. De standaard 8-bits ASCII-tekenset is echter een subset van Unicode van 0 tot 127. Daarom zijn ASCII-tekens nog steeds geldig in C # ...

Antwoord geven:

1. Gegevenstypen voor geheel getal:

korte int, niet-ondertekende korte int, int, niet-ondertekende int, lang, niet-ondertekende lang.

1. Gegevenstypen met drijvende komma (komt overeen met reële typen):

float, dubbel, lang dubbel.

1. Karakter gegevenstype:

char (ondertekend char), niet-ondertekend char, wchar_t.

1. Booleaans gegevenstype:

bool.

1. Opgesomd gegevenstype (geïntroduceerd in Visual C ++):

opsomming.

2. Wat zijn de kenmerken van het gebruik van integer-gegevenstypen?

In C++ zijn de basisgegevenstypen voor gehele getallen: short int, unsigned short int, int, unsigned int, long (long int), unsigned long (unsigned long int).

Deze gegevenstypen vertegenwoordigen waarden van een verscheidenheid aan gehele getallen. Bijvoorbeeld:

Gegevenstypen die beginnen met het niet-ondertekende voorvoegsel kunnen alleen positieve getallen bevatten.

Gegevens van het type short int, unsigned short int nemen twee keer minder geheugenruimte in beslag dan gegevens van het type int, unsigned int.

Gegevens van het type long, unsigned long nemen twee keer zoveel geheugenruimte in beslag als gegevens van het type int, unsigned int.

3. Hoe beschrijf ik een variabele met de naam x van het type integer in een programma?

Antwoord geven:

Als resultaat, onder de variabele x geheugenruimte van 4 bytes zal worden toegewezen. De grootte van het geheugen dat voor de variabele wordt toegewezen, is afhankelijk van de kenmerken van de computer, het type besturingssysteem en de compilerinstellingen.

4. Hoe schrijf je het getal 239 in een variabele van het type integer?

Gebruik hiervoor de toewijzingsoperator, die wordt aangegeven met het symbool '='.

Antwoord 1. Een getal invoeren in een variabele na de beschrijving ervan.

Antwoord 2. Een getal in een variabele invoeren tijdens de aangifte (initiële initialisatie).

5. Wat zijn de kenmerken van gegevenstypen met drijvende komma?

Gegevenstypen met drijvende komma mogen waarden vertegenwoordigen uit een reeks reële getallen. Bijvoorbeeld:

C ++ heeft de volgende basisgegevenstypen met drijvende komma:

float, dubbel, lang dubbel.

Een dubbele variabele neemt 2 keer meer ruimte in beslag in het computergeheugen dan een float-variabele.

Ook neemt een variabele van het lange dubbele type 2 keer meer ruimte in het computergeheugen in beslag dan een variabele van het dubbele type.

6. Hoe beschrijf je een variabele die een drijvende-kommawaarde krijgt?

Een voorbeeld van het beschrijven van variabelen van het type float, double, long double:

7. Hoe numerieke waarden naar een variabele met drijvende komma te schrijven?

Een voorbeeld van het invoeren van numerieke gegevens in variabele typen met drijvende komma:

8. Hoe converteer je een variabele van het type float naar het type int?

Hiervoor wordt de bewerking van typegieten gebruikt. Tussen haakjes moet u de naam aangeven van het type waarnaar de conversie plaatsvindt.

Bij het gebruik van typecast-bewerkingen moet u rekening houden met de beperkingen die gelden voor typen die minder ruimte innemen in het computergeheugen.

Een variabele van het type short int kan bijvoorbeeld een kleiner aantal getallen vertegenwoordigen dan variabelen van het type float, double. In de volgende lijst vindt een waardeoverloop plaats in een variabele van het type short int:

9. Hoe converteer je een variabele van type int naar type double?

Een voorbeeld van casten van int naar double:

10. Wat zijn de kenmerken van het gebruik van char data (karakter data) in een programma?

De char-gegevens vertegenwoordigen de tekenwaarde van de code die met het toetsenbord is ingevoerd. De tekencode is een geheel getal.

De tekencode voor 'f' is bijvoorbeeld 102.

Een codefragment waarin de tekencode wordt berekend:

De char-gegevens zijn dezelfde gehele getallen. Char-gegevens nemen 1 byte in beslag in het computergeheugen.

De teken-naar-code-relatie bevindt zich in de Windows-tekentabel. Tekens met codes 0 tot en met 127 zijn door BIOS gereserveerde tekens. Ze omvatten de meest gebruikte symbolen, cijfersymbolen, symbolen van het Latijnse alfabet. Deze symbolen kunnen niet worden gewijzigd.

Tekens met codes van 128 tot 255 zijn regionale tekens die zijn gekoppeld aan het specifieke alfabet van de computer waarop het Windows-besturingssysteem is geïnstalleerd.

11. Wat zijn de kenmerken van het gebruik van gegevens van het type bool (logisch type)?

Variabelen van het type bool kunnen slechts twee waarden aannemen:

waar waar,

vals is vals.

Deze variabelen worden gebruikt om booleaanse expressies te testen. De numerieke waarde waar is 1. De numerieke waarde false is 0.

Een codefragment dat de numerieke waarden waar en onwaar definieert:

Een codefragment dat int- en float-types naar bool converteert:

12. Hoe de grootte van het geheugen bepalen dat wordt ingenomen door een variabele van een bepaald type?

Hiervoor wordt de bewerking sizeof () gebruikt.

Een codefragment dat de grootte van sommige gegevenstypen bepaalt:

13. Hoe worden variabelen van verschillende typen geïnitialiseerd?

14. Hoe bepaal je de maximaal toelaatbare (minimaal toelaatbare) waarde van een variabele van een bepaald type?

Het .NET Framework gebruikt de eigenschappen MaxValue en MinValue om de maximaal of minimaal acceptabele waarde te bepalen voor een variabele van een bepaald type.

Voorbeelden van het bepalen van de grenswaarden van variabelen van verschillende typen.

Voor variabelen van het type int:

Voor variabelen van het type short int:

Voor variabelen van het type unsigned int:

Voor float-variabelen:

Voor variabelen van het type double:

Voor variabelen van het type char:

15. Wat zijn de kenmerken van het gebruik van het enum-type?

Het enum-type is een opgesomd gegevenstype. Het specificeert geheugensteuntjes voor sets van gehele waarden. Elke mnemonische betekenis heeft een specifieke inhoud en wordt weergegeven door een geheel getal.

Een voorbeeld van het gebruik van het enum-type om de maanden van het jaar weer te geven:

Het gegeven voorbeeld beschrijft een variabele met de naam mn van het type enum months. Geheugensteuntjes voor maanden (januari, februari,…) beginnen bij 0 (0, 1, 2,…). Het geheugensteuntje januari is het gehele getal 0, het geheugensteuntje februari is het gehele getal 1, enzovoort.

Dus, met behulp van het enum-type, kunt u mnemonische notaties in de programmatekst gebruiken voor een betere duidelijkheid van de broncode.

Je kunt dit ook schrijven:

16. Wat zijn de kenmerken van de toepassing van het type?leegte in programma's voorC++ ?

Het void-gegevenstype wordt in de volgende gevallen gebruikt:

• als u een functie moet beschrijven die geen waarde retourneert (zie voorbeeld);
• als u een functie moet beschrijven die geen parameters ontvangt (zie voorbeeld).

Voorbeeld... De functie MyFun () zonder parameters, die geen waarde retourneert (retourneert het void-type) en geen parameters ontvangt.

17. Is het mogelijk om een ​​variabele van het type te declareren?leegte in een programma?

Het is onmogelijk, omdat het void-type niet aan een waarde is gekoppeld.

Het declareren van een variabele van het type void leidt tot een compilatiefout met de uitvoer van het bericht:

18. Wat zijn de kenmerken van de toepassing van het type?wchar_ t vVisueel C++ ?

Variabelen van het type char (zie vorige punten) worden gebruikt om 8-bit ASCII-tekens op te slaan.

Het type wchar_t wordt gebruikt om tekens op te slaan die deel uitmaken van grote tekensets. Het Chinese alfabet heeft bijvoorbeeld een enorm aantal karakters. 8 bits is niet genoeg om de hele tekenset van het Chinese alfabet weer te geven. Daarom, als u het programma op de internationale markt moet gebruiken, is het raadzaam om het char-type te vervangen door wchar_t.

Voorbeeld met behulp van het wchar_t-type.

Bij het schrijven van een programma in welke taal dan ook, moet u verschillende variabelen gebruiken om verschillende informatie op te slaan. Variabelen zijn niets meer dan gereserveerde geheugenlocaties voor het opslaan van waarden. Dit betekent dat wanneer u een variabele maakt, u wat ruimte in het geheugen bespaart.

U kunt informatie van verschillende gegevenstypen opslaan, zoals teken, breed teken, geheel getal, drijvende komma, dubbele drijvende komma, boolean, enz. Op basis van het gegevenstype van de variabele wijst het besturingssysteem geheugen toe en beslist wat er kan worden opgeslagen in de gereserveerd geheugen...

Primitieve ingebouwde typen

C++ biedt de programmeur een rijke set aan ingebouwde en door de gebruiker gedefinieerde datatypes. De volgende tabellen geven een overzicht van de zeven basis C++-gegevenstypen:

Sommige van de basistypen kunnen worden gewijzigd met behulp van een of meer modifiers van dit type:

• ondertekend
• niet ondertekend
• kort

De volgende tabel toont het type variabele, de hoeveelheid geheugen die nodig is om een ​​waarde in het geheugen op te slaan en wat de maximale en minimale waarde is die in dergelijke variabelen kan worden opgeslagen.

De grootte van de variabelen kan verschillen van de grootte in de bovenstaande tabel, afhankelijk van de compiler en de computer die je gebruikt. Hieronder ziet u een voorbeeld dat de juiste grootte geeft voor de verschillende gegevenstypen op uw computer.

#erbij betrekken namespace std; gebruiken; int main () (cout<< "Size of char: " << sizeof(char) << endl; cout << "Size of int: " << sizeof(int) << endl; cout << "Size of short int: " << sizeof(short int) << endl; cout << "Size of long int: " << sizeof(long int) << endl; cout << "Size of float: " << sizeof(float) << endl; cout << "Size of double: " << sizeof(double) << endl; cout << "Size of wchar_t: " << sizeof(wchar_t) << endl; return 0; }

Dit voorbeeld gebruikt eindel, die na elke regel een teken voor een nieuwe regel introduceert, en de operator<< используется для передачи нескольких значений на экран. Мы также используем оператор De grootte van () om de grootte van verschillende gegevenstypen te krijgen.

Wanneer de bovenstaande code wordt gecompileerd en uitgevoerd, produceert deze de volgende uitvoer, die van machine tot machine kan verschillen:

Maat char: 1 Maat int: 4 Maat short int: 2 Maat long int: 4 Maat float: 4 Maat double: 8 Maat wchar_t: 4

Typedef-aangiften

U kunt een nieuwe naam voor een bestaand type maken met typedef. Hieronder volgt de eenvoudige syntaxis voor het definiëren van een nieuw type met behulp van een typedef:

Typedef typ nieuwenaam;

Het volgende vertelt de compiler bijvoorbeeld dat kicking een andere naam is voor int:

Typedef int voeten;

Nu is de volgende declaratie volkomen legaal en creëert een integer-variabele genaamd afstand:

Voeten afstand;

opgesomde typen

Een opgesomd type declareert een optionele typenaam en een set van nul of meer identifiers die kunnen worden gebruikt als waarden van het type. Elke enumerator is een constante waarvan het type een opsomming is. Het gebruik van het trefwoord is vereist om een ​​opsomming te maken opsomming... Algemeen overzicht van het opsommingstype:

Enum enum-naam (lijst met namen) var-list;

Hier is enum-naam de naam van het enum-type. De lijst met namen wordt gescheiden door een komma. De volgende code definieert bijvoorbeeld een opsomming van kleuren die kleuren worden genoemd en een variabele c van het type kleur. Ten slotte krijgt c de waarde "blauw" toegewezen.

Enum kleur (rood, groen, blauw) c; c = blauw;

De standaardwaarde van de voornaam is 0, de tweede naam is 1 en de derde is 2. enz. Maar u kunt een naam, een specifieke waarde specificeren door een initialisatie toe te voegen. In de volgende lijst zou groen bijvoorbeeld 5 zijn.

Enum-kleur (rood, groen = 5, blauw);

Hier is blauw 6 omdat elke naam groter is dan de vorige.