Variabelen in C-taal. Gegevenstypen en hun aangifte

De hoogste prioriteit wordt gegeven aan het type waarbij de minste hoeveelheid informatie verloren gaat. U mag geen misbruik maken van impliciete typeconversie, aangezien zich verschillende onvoorziene situaties kunnen voordoen.

• Expliciete conversie in tegenstelling tot impliciet wordt het uitgevoerd door de programmeur. Er zijn verschillende manieren om deze conversie uit te voeren:

1. Converteren naar stijlen C: (zweven) een
2. Converteren naar stijlen C++: vlot()

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

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

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

Typ static_cast<Тип>(voorwerp);

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

Typeconst_cast< Type> (voorwerp);

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

Typeherinterpreteren_vorm< Type> (voorwerp);

dynamische_cast- gebruikt voor dynamische typeconversie, implementeert pointer- of referentiecasting. Syntaxis:

Typedynamisch _vorm< Type> (voorwerp);

Controlekarakters

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

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 - initializer.

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 initialisator 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 binair 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;

Operatoren voor aangifte

Constanten in SI

In SI kunt u ook variabelen maken die een constante waarde hebben (hun waarde kan niet worden gewijzigd). De declaratie van dergelijke “variabelen” heeft de volgende syntaxis: const type naam1=waarde1[,naam2=waarde2[,...]]; Voorbeelden:
   const niet-ondertekend int x=80, y=25;
   const dubbel pi=3,1415;

Operator voor het maken van gegevenstypen in SI

Gegevenstypen. Een programma in proceduretalen, waaronder C, is een beschrijving van bewerkingen op hoeveelheden van verschillende typen. Een type definieert de reeks waarden die een waarde kan aannemen en de reeks bewerkingen waaraan deze kan deelnemen.

In de C-taal worden typen geassocieerd met namen (identificatoren) van hoeveelheden, dat wil zeggen met variabelen. Een variabele in de C-taal is gekoppeld aan een geheugenlocatie. Het variabeletype specificeert de grootte van de cel, de manier waarop de inhoud ervan wordt gecodeerd en aanvaardbare transformaties van de waarde van deze variabele. Alle variabelen moeten worden gedeclareerd voordat ze worden gebruikt. Elke variabele mag slechts één keer worden gedeclareerd.

De beschrijving bestaat uit een typespecificatie gevolgd door een lijst met variabelen. Variabelen in de lijst worden gescheiden door komma's. Aan het einde van de beschrijving wordt een puntkomma geplaatst.

Voorbeeldbeschrijvingen:

teken a,b; /* Variabelen a en b hebben type

char */ intх; /* Variabele x is van het type int

*/ teken sym; /" Variabelen sym van het type char worden beschreven;

*/ int count.num; /* aantal en aantal van type int */

Aan variabelen kunnen initiële waarden worden toegewezen binnen hun declaraties. Als een variabelenaam wordt gevolgd door een gelijkteken en een constante, dan dient die constante als initialisator.

Voorbeelden: char backch = "\0";

Laten we eens kijken naar de belangrijkste typen in de C-taal.

int - geheel getal ("geheel getal"). Waarden van dit type zijn gehele getallen uit een beperkt bereik (meestal van - 32768 tot 32767). Het bereik wordt bepaald door de celgrootte voor het type en is afhankelijk van de specifieke computer. Daarnaast zijn er functiewoorden die kunnen worden gebruikt met het type int: short int (“short integer” - “short integer”), unsigned int (“unsigned integer” – “unsigned integer”), long int (“long integer”) ”), die het weergavebereik van getallen verkleinen of juist vergroten.

verkoold- karakter (“karakter”). De geldige waarde voor dit type is één teken (niet te verwarren met tekst!). Het symbool is geschreven in apostrofs.

Voorbeelden:"x"2"?"

In het computergeheugen neemt een teken één byte in beslag. In feite is het geen symbool dat wordt opgeslagen, maar een getal: de symboolcode (van 0 tot 255). Speciale coderingstabellen geven alle geldige tekens en hun bijbehorende codes aan.

In de C-taal is het toegestaan ​​om het char-type numeriek te gebruiken, dat wil zeggen om bewerkingen uit te voeren met de tekencode, met behulp van de integer-type-specificatie tussen haakjes - (int).

zweven - echt (zwevende komma). Waarden van dit type zijn getallen, maar, in tegenstelling tot char en int, niet noodzakelijk gehele getallen.

12,87 -316,12 -3,345e5 12,345e-15

dubbele - dubbele precisie reële getallen. Dit type is vergelijkbaar met het float-type, maar heeft een aanzienlijk groter bereik aan waarden (bijvoorbeeld voor het Borland-C-programmeersysteem van 1.7E-308 tot 1.7E+308 in plaats van het bereik van 3.4E-38 tot 3.4E+38 voor het vlottertype). Een toename van het bereik en de nauwkeurigheid van de getalweergave leidt echter tot een afname van de snelheid van de programma-uitvoering en een verspillend gebruik van computer-RAM.

Houd er rekening mee dat er geen tekenreekstype in deze lijst voorkomt. Er is geen speciaal type in C dat kan worden gebruikt om tekenreeksen te beschrijven. In plaats daarvan worden strings weergegeven als een array van char-elementen. Dit betekent dat de tekens in de string zich in aangrenzende geheugencellen bevinden.

Opgemerkt moet worden dat het laatste element van de array het teken \0 is. Dit is het teken "null" en wordt in de C-taal gebruikt om het einde van een tekenreeks te markeren. Het nulteken is niet het getal 0; het wordt niet afgedrukt en heeft het nummer 0 in de ASCII-codetabel. De aanwezigheid van een nulteken betekent dat het aantal cellen in de array gelijk moet zijn. minstens één meer dan het aantal tekens dat in het geheugen moet worden toegewezen.

Laten we een voorbeeld geven van het gebruik van strings.

Programma 84

#erbij betrekken voornaamst()

scanf("%s",string) ;

printf("%s",string);

Dit voorbeeld beschrijft een array van 31 geheugenlocaties, waarvan er 30 een enkel char-element kunnen bevatten. Het wordt ingevoerd bij het aanroepen van de functie scanf("%s",string); "&" ontbreekt bij het opgeven van een tekenarray.

Wegwijzers. Een pointer is een symbolische weergave van het adres van een geheugenlocatie die aan een variabele is toegewezen.

&name is bijvoorbeeld een verwijzing naar de naamvariabele;

Hier & is de handeling voor het verkrijgen van een adres. Het werkelijke adres is een getal en de symbolische weergave van het adres &naam is een aanwijzerconstante.

De C-taal heeft ook pointertypevariabelen. Net zoals de waarde van een char-variabele een teken is, en de waarde van een int-variabele een geheel getal is, is de waarde van een pointer-variabele het adres van een bepaalde waarde.

Als we de aanwijzer de naam ptr geven, kunnen we een verklaring als deze schrijven:

ptr = /* wijst de adresnaam toe aan de variabele ptr */

We zeggen in dit geval dat prt een “pointer to”-naam is. Het verschil tussen de twee notaties: ptr en &name is dat prt een variabele is, terwijl &name een constante is. Indien nodig kunt u de ptr-variabele naar een ander object laten verwijzen:

ptr= /* ptr verwijst naar bah, niet naar naam */

Nu is de waarde van de variabele prt het adres van de variabele bah. Stel dat we weten dat de variabele ptr een verwijzing bevat naar de variabele bah. Om toegang te krijgen tot de waarde van deze variabele, kunt u vervolgens de bewerking "indirecte adressering" * gebruiken:

val = *ptr; /* definieer de waarde waarnaar ptr verwijst */ De laatste twee instructies samen zijn equivalent aan het volgende:

Dus, als je achter het bord staat & gevolgd door de naam van de variabele, het resultaat van de bewerking is het adres van de opgegeven variabele; &nurse geeft het adres van de variabele verpleegkundige; wanneer een * wordt gevolgd door een verwijzing naar een variabele, is het resultaat van de bewerking de waarde die in de geheugenlocatie op het opgegeven adres is geplaatst.

Voorbeeld: verpleegkundige = 22;

ptr = /* verwijzing naar verpleegkundige */

Het resultaat is de toewijzing van waarde 22 aan de variabele val.

Het is niet voldoende om te zeggen dat een variabele een pointer is. Daarnaast is het noodzakelijk om aan te geven op welk type variabele deze pointer betrekking heeft. De reden is dat verschillende soorten variabelen verschillende aantallen geheugenlocaties in beslag nemen, terwijl voor sommige pointergerelateerde bewerkingen kennis nodig is van de hoeveelheid toegewezen geheugen.

Voorbeelden correcte beschrijving van pointers: int *pi; teken *pc;

De typespecificatie specificeert het type van de variabele waarnaar de pointer verwijst, en het *-teken identificeert de variabele zelf als een pointer. Beschrijving van het type int *pi; zegt dat pi een pointer is en dat *pi een int-waarde is.

De C-taal biedt de mogelijkheid om namen van gegevenstypen te definiëren. U kunt aan elk gegevenstype een naam toewijzen met behulp van een typedef en deze naam later gebruiken bij het beschrijven van objecten.

Formaat: typedef<старый тип> <новый тип> Voorbeeld: typedef lang GROOT; /* definieert het grote type, wat equivalent is aan het lange type */

Een typedef introduceert geen nieuwe typen, maar voegt alleen een nieuwe naam toe aan een bestaand type. Variabelen die op deze manier worden gedeclareerd, hebben exact dezelfde eigenschappen als variabelen die expliciet worden gedeclareerd. Het hernoemen van typen wordt gebruikt om betekenisvolle of afgekorte typenamen te introduceren, wat de begrijpelijkheid van programma's verbetert, en om de overdraagbaarheid van programma's te verbeteren (de namen van hetzelfde gegevenstype kunnen op verschillende computers verschillen).

Operaties. De C-taal onderscheidt zich door een grote verscheidenheid aan bewerkingen (meer dan 40). Hier zullen we alleen de belangrijkste beschouwen, tabel. 3.3.

Rekenkundige bewerkingen. Deze omvatten

Voeg(+), toe

Aftrekken (binair) (-),

Vermenigvuldiging (*),

Divisie (/),

Rest van gehele divisie (%),

Aftrekken (unair) (-) .

De C-taal heeft een regel: als het deeltal en de deler van het type int zijn, wordt de deling volledig uitgevoerd, dat wil zeggen dat het fractionele deel van het resultaat wordt weggegooid.

Zoals gebruikelijk worden bij uitdrukkingen de bewerkingen vermenigvuldigen, delen en resten uitgevoerd vóór optellen en aftrekken. Gebruik haakjes om de volgorde van acties te wijzigen.

Programma 85

#erbij betrekken

5 = -3 + 4 * 5 - 6; printf("%d\n",s);

s = -3 + 4%5 - 6; printf("%d\n",s);

s = -3 * 4% - 6/5; printf("%d\n",s);

s= (7 + 6)%5/2; printf("%d\n",s);

Resultaat van programma-uitvoering: 11 1 0 1

Tabel 3.3 Prioriteit en volgorde van bewerkingen