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 (identifiers) 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 moet 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 - typ int

*/ teken sym; /" Sym-variabelen worden beschreven typ char;

*/ 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 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 teken dat wordt opgeslagen, maar een getal: de tekencode (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 soort vlotter). Een toename van het bereik en de nauwkeurigheid van getalrepresentatie leidt echter tot een afname van de snelheid van programma-uitvoering en verspillend gebruik van RAM computer.

Houd er rekening mee dat deze lijst exclusief is tekenreekstype. 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 in de C-taal wordt het gebruikt om het einde van een string 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. Door ten minste, één meer dan het aantal tekens dat in het geheugen moet worden opgeslagen.

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 naar"-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 gelijkwaardig 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 om welk type variabele het gaat deze wijzer. De reden is dat variabelen van verschillende typen in beslag worden genomen ander nummer geheugenlocaties, terwijl voor sommige pointergerelateerde bewerkingen kennis vereist is van de hoeveelheid toegewezen geheugen.

Voorbeelden juiste omschrijving wijzers: 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 al bestaande soort. 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 als geheel uitgevoerd, d.w.z. fractioneel deel 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

Dit spiekbriefje geeft informatie over de belangrijkste gegevenstypen van de programmeertaal C++ en de kenmerken van hun implementatie. Aan het einde van het record bevindt zich ook een tabel met de waardenbereiken van deze typen.

Gegevenstypeconcept

Het hoofddoel van elk programma is het verwerken van gegevens. Gegevens verschillende soorten anders opgeslagen en verwerkt. In elke algoritmische taal moet elke constante, variabele, uitdrukking of functie een specifiek type hebben.

Het gegevenstype definieert:

• interne weergave van gegevens in computergeheugen;
• de reeks waarden die hoeveelheden van dit type kunnen aannemen;
• bewerkingen en functies die op de grootheden van dit type kunnen worden toegepast.

Op basis van deze kenmerken selecteert de programmeur het type van elke grootheid die in het programma wordt gebruikt om echte objecten weer te geven. Met een vereiste typedeclaratie kan de compiler de geldigheid van verschillende programmaconstructies controleren. Het type waarde bepaalt de machine-instructies die zullen worden gebruikt om de gegevens te verwerken.

Alle soorten C++-talen kunnen worden onderverdeeld in eenvoudig En composiet . De C++-taal definieert er zes voornaamst gegevenstypen om geheel getal, reëel, karakter en weer te geven logische waarden. Op basis van deze typen kan de programmeur een beschrijving invoeren composiet typen. Deze omvatten arrays, opsommingen, functies, structuren, referenties, pointers, unies en klassen.

Basisgegevenstypen in C++

Basisgegevenstypen (standaardgegevens) worden vaak rekenkundig genoemd omdat ze kunnen worden gebruikt in rekenkundige bewerkingen. Om de belangrijkste typen te beschrijven, worden de volgende gedefinieerd:

1. int(int);
2. teken(teken);
3. wchar_t(breedchar);
4. bool(booleaans);
5. zweven(echt);
6. dubbel (dubbele precisie echt).

De eerste vier typen worden integer ( geheel ), de laatste twee - typen met drijvende komma . De code die de compiler genereert voor het verwerken van gehele waarden is anders dan de code voor drijvende-kommawaarden.

Er zijn er vier typespecificatie , verduidelijking van de interne representatie en het bereik van waarden van standaardtypen:

• kort (kort);
• lang(lang);
• ondertekend(ondertekend);
• niet ondertekend.

Type geheel getal (int)

De grootte van het int-type wordt niet gedefinieerd door de standaard, maar is afhankelijk van de computer en de compiler. Voor een 16-bits processor worden 2 bytes toegewezen voor waarden van dit type, voor een 32-bits processor - 4 bytes.

De korte specificatie vóór de typenaam geeft aan de compiler aan dat er 2 bytes moeten worden toegewezen voor het nummer, ongeacht de bitcapaciteit van de processor. De lange specificatie betekent dat de gehele waarde 4 bytes in beslag neemt. Op een 16-bits computer zijn de equivalenten dus int en short int, en op een 32-bits computer zijn de equivalenten int en long int.

Interne vertegenwoordiging waarden van het type geheel getal - geheel getal in binaire code. Wanneer u de ondertekende specificatie gebruikt, wordt het meest significante bit van het getal geïnterpreteerd als ondertekend (0 is een positief getal, 1 is een negatief getal). Met de niet-ondertekende specificatie kunnen alleen positieve getallen worden weergegeven, aangezien het meest significante bit wordt behandeld als onderdeel van de code van het getal. Het bereik van waarden van het type int hangt dus af van de specificaties. Bereiken van waarden van waarden van het gehele type met verschillende specificaties voor IBM PC-compatibele computers worden gegeven in de tabel “Waardebereiken eenvoudige soorten gegevens" aan het einde van de opname.

Standaard worden alle typen gehele getallen als ondertekend beschouwd, wat betekent dat de ondertekende specificatie kan worden weggelaten.

Constanten die in een programma worden gevonden, krijgen afhankelijk van hun type het ene of het andere type toegewezen. Als de programmeur om wat voor reden dan ook niet tevreden is met dit type, kan hij het vereiste type expliciet aangeven met behulp van de achtervoegsels L, l (lang) en U, u (niet-ondertekend). De constante 32L zal bijvoorbeeld van het type long zijn en 4 bytes in beslag nemen. U kunt de achtervoegsels L en U tegelijkertijd gebruiken, bijvoorbeeld 0x22UL of 05Lu.

Opmerking

De typen korte int, lange int, ondertekende int en niet-ondertekende int kunnen worden afgekort tot respectievelijk kort, lang, ondertekend en niet-ondertekend.

Tekentype (char)

Aan een tekentypewaarde wordt een aantal bytes toegewezen dat voldoende is om elk teken uit de tekenset te huisvesten van deze computer, die de naam van het type bepaalde. Meestal is dit 1 byte. Het char-type kan, net als andere typen gehele getallen, ondertekend of niet-ondertekend zijn. Ondertekende waarden kunnen waarden opslaan in het bereik van -128 tot 127. Met behulp van de niet-ondertekende specificatie kunnen waarden variëren van 0 tot 255. Dit is voldoende om elk teken in de ASCII-tekenset van 256 tekens op te slaan. Waarden van het char-type worden ook gebruikt om gehele getallen op te slaan die de grenzen van de opgegeven bereiken niet overschrijden.

Uitgebreid tekentype (wchar_t)

Het type wchar_t is ontworpen om te werken met een set tekens waarvoor 1 byte niet voldoende is om bijvoorbeeld Unicode te coderen. De omvang van dit type is implementatieafhankelijk; in de regel komt het overeen met het type kort. Tekenreeksconstanten van het type wchar_t worden geschreven met het voorvoegsel L, bijvoorbeeld L»Gates».

Booleaans type (bool)

Booleaanse waarden kunnen alleen de waarden waar en onwaar aannemen, wat dat ook is gereserveerde woorden. Intern vertegenwoordigingsformulier valse waarden- 0 (nul). Elke andere waarde wordt als waar geïnterpreteerd. Wanneer geconverteerd naar een geheel getaltype, heeft true de waarde 1.

Drijvende-kommatypes (float, double en long double)

De C++-standaard definieert drie gegevenstypen voor het opslaan van reële waarden: float, double en long double.

Gegevenstypen met drijvende komma worden anders in het computergeheugen opgeslagen dan gegevenstypen met gehele getallen. Interne vertegenwoordiging echt nummer bestaat uit twee delen: de mantisse en de bestelling. Op IBM PC-compatibele computers beslaan float-waarden 4 bytes, waarvan één binair cijfer is toegewezen voor het mantisse-teken, 8 bits voor de exponent en 23 voor de mantisse. De mantisse is een getal groter dan 1,0 maar kleiner dan 2,0. Omdat het eerste cijfer van de mantisse altijd 1 is, wordt dit niet opgeslagen.

Voor dubbele waarden die 8 bytes bezetten, worden respectievelijk 11 en 52 bits toegewezen voor de exponent en mantisse. De lengte van de mantisse bepaalt de nauwkeurigheid van het getal, en de lengte van de exponent bepaalt het bereik ervan. Zoals je kunt zien in de tabel aan het einde van het item, met hetzelfde aantal bytes toegewezen aan float- en long int-waarden, lopen de bereiken van hun toegestane waarden sterk uiteen vanwege de interne representatievorm.

De lange specificatie vóór een dubbele typenaam geeft aan dat er 10 bytes zijn toegewezen voor de waarde ervan.

Drijvende-kommaconstanten zijn standaard van het dubbele type. U kunt het type van een constante expliciet specificeren met behulp van de achtervoegsels F, f (zwevend) en L, l (lang). De constante 2E+6L zal bijvoorbeeld van het type long double zijn, en de constante 1.82f zal van het type float zijn.

Om draagbaar te schrijven verschillende platforms programma's kunnen geen aannames doen over de grootte van een int-type. Om dit te verkrijgen, moet u de grootte van de bewerking gebruiken, waarvan het resultaat de grootte van het type in bytes is. Bijvoorbeeld voor een operatiekamer MS-DOS-systemen sizeof(int) zal resulteren in 2, maar op Windows 98 of OS/2 zal het resultaat 4 zijn.

De ANSI-standaard specificeert geen waardebereiken voor basistypen; de relaties tussen hun groottes zijn bijvoorbeeld gedefinieerd:

sizeof(float) ≤ slzeof(dubbel) ≤ sizeof(lang dubbel)
sizeof(char) ≤ slzeof(kort) ≤ sizeof(int) ≤ sizeof(lang)

Opmerking

Minimaal en maximaal geldige waarden voor integer-typen zijn afhankelijk van de implementatie en worden gegeven in het headerbestand (), kenmerken van echte typen - in het bestand (), evenals in de klassensjabloon numeriek_limits

typ leegte

Naast de genoemde talen omvatten de belangrijkste soorten talen typ leegte, maar de set waarden van dit type is leeg. Het wordt gebruikt om functies te definiëren die geen waarde retourneren, om aan te geven lege lijst functieargumenten, als het basistype voor pointers en bij typecast-bewerkingen.

Waardebereiken van eenvoudige gegevenstypen in C++ voor IBM PC-compatibele computers

Q: Wat betekent de term IBM PC-compatibele computer?
A: Een IBM PC-compatibele computer is een computer die qua architectuur dicht bij de IBM PC, XT en AT ligt. IBM-pc-compatibel computers zijn gebouwd op microprocessors die compatibel zijn met Intel 8086 (en, zoals u weet, alle later uitgebrachte microprocessors). Intel-processors vol hebben achterwaarts compatibel uit 8086). In feite zijn dit bijna allemaal moderne computers.

Er zijn verschillende soorten gehele en reële typen geïntroduceerd, die verschillen in het bereik en de nauwkeurigheid van de gegevensrepresentatie, om de programmeur de kans te geven de mogelijkheden van specifieke apparatuur zo effectief mogelijk te gebruiken, aangezien de snelheid van berekeningen en de hoeveelheid geheugen afhankelijk zijn van de keuze van het type. Maar een programma dat voor één type computer is geoptimaliseerd, is mogelijk niet overdraagbaar naar andere platforms, dus in het algemeen moet u vermijden te vertrouwen op specifieke kenmerken van gegevenstypen.

Type	Bereik van waarden	Grootte (bytes)
bool	waar en onwaar	1
ondertekende char	-128 … 127	1
niet-ondertekend teken	0 … 255	1
gesigneerd korte int	-32 768 … 32 767	2
niet-ondertekende korte int	0 … 65 535	2
gesigneerd lange int	-2 147 483 648 … 2 147 483 647	4
niet-ondertekend lange int	0 … 4 294 967 295	4
vlot	3.4e-38 … 3.4e+38	4
dubbele	1.7e-308 … 1.7C+308	8
lange dubbele	3,4e-4932 … 3,4e+4932	10

Voor echte typen wordt in de tabel weergegeven absolute waarden minimum- en maximumwaarden.

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 kan voorkomen verschillende soorten. Dynamisch typen wordt ondersteund Javascript, 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 net zo. 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;
• extern;
• register.

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 nummers dienovereenkomstig ondertekend; ze kunnen alleen binnen het bereik liggen positieve cijfers. 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, minder vaak - cijfers. Tekenwaarden 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.

Leegte heeft 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 “

Naast het verdelen van gegevens in variabelen en constanten, is er een classificatie van gegevens op type. De beschrijving van variabelen bestaat voornamelijk uit het declareren van hun type. Het gegevenstype karakteriseert het bereik van zijn waarden en de vorm van weergave in het computergeheugen. Elk type wordt gekenmerkt door een reeks bewerkingen die op gegevens worden uitgevoerd. Traditioneel zijn er zulke in universele programmeertalen standaard typen, als geheel getal, reëel, symbolisch en logisch 3. Laten we meteen opmerken dat er geen logisch type is in C. Een expressie (in het specifieke geval een variabele) wordt als waar beschouwd als deze niet nul is, anders wordt deze als onwaar beschouwd.

Het bestaan ​​van twee numerieke typen (geheel getal en reëel) houdt verband met twee mogelijke vormen van weergave van getallen in het computergeheugen.

Gegevens hele soort opgeslagen in presentatievorm vast punt. Het wordt gekenmerkt door absolute precisie bij het weergeven van getallen en het uitvoeren van bewerkingen daarop, evenals een beperkt bereik aan getalwaarden. Het type geheel getal wordt gebruikt voor gegevens die in principe geen fractioneel deel kunnen hebben (aantal personen, auto's etc., getallen en tellers).

Typ echt komt overeen met de vorm van getalrepresentatie drijvende punt, die wordt gekenmerkt door een benaderende weergave van een getal met een bepaald aantal significante cijfers (mantisse-tekens) en een groot bereik in de orde van het getal, wat het mogelijk maakt om zowel zeer grote als zeer kleine getallen in absolute waarde weer te geven. Vanwege de geschatte weergave van gegevens van het echte type, kunnen hun het is onjuist om op gelijkheid te vergelijken.

In moderne implementaties van universele programmeertalen zijn er meestal verschillende integer- en verschillende reële typen, die elk worden gekenmerkt door hun eigen geheugengrootte die is toegewezen aan één waarde en dienovereenkomstig hun bereik van getalswaarden, en voor reële typen - en hun precisie (het aantal cijfers van de mantisse).

Gegevens karaktertype waarden aannemen voor de volledige reeks tekens die voor een bepaalde computer zijn toegestaan. Er wordt één byte toegewezen om één tekenwaarde op te slaan; tekens worden gecodeerd in overeenstemming met een standaardcoderingstabel (meestal ASCII).

Er zijn 4 basistypen in C:

verkoold- karaktertype;

int- een heel type,

vlot- echt type met enkele precisie,

dubbele- Echt type met dubbele precisie.

Gebruik om afgeleide typen te definiëren kwalificatietoernooien:kort(kort) - gebruikt met type int,lang(lang) - gebruikt met typen int En dubbele;ondertekend(met een bordje), niet ondertekend(niet-ondertekend) - is van toepassing op elk geheel getaltype. Als het woord niet-ondertekend ontbreekt, wordt de waarde als ondertekend beschouwd, d.w.z. d.w.z. de standaard is ondertekend. Vanwege de toelaatbaarheid van willekeurige combinaties van kwalificaties en namen basistypenéén type kan meerdere aanduidingen hebben. Informatie over standaard C-typen wordt weergegeven in de tabellen 1 en 2. Synoniemdescriptoren worden weergegeven in de cellen van de eerste kolom, gescheiden door komma's.

Tabel 1. Standaard C-gegevenstypen met gehele getallen

Gegevenstype		Bereik van waarden
char, getekend char
niet-ondertekend int, niet-ondertekend
int, ondertekend int, kort int, kort
		2147483648...2147483647

Interessant is dat in C het char-type kan worden gebruikt als een teken of als een geheel getal, afhankelijk van de context.

Tabel 2. Standaard echte C-gegevenstypen

Opmerking. Om programma's voor het eerste deel van de handleiding te schrijven, hebben we voornamelijk nodig twee soorten:vlotEnint.

  Een datatype is een beschrijving van het waardenbereik dat een variabele van een bepaald type kan aannemen. Elk gegevenstype wordt gekenmerkt door:
   1. aantal bezette bytes (grootte)
   2. het bereik van waarden dat een variabele van dit type kan aannemen.

Alle gegevenstypen kunnen worden onderverdeeld in de volgende typen:
   1. eenvoudige (scalaire) en complexe (vector) typen;
   2. basis (systeem) en gebruiker (gedefinieerd door de gebruiker).
  In de SI-taal wordt het systeem van basistypen gevormd door vier gegevenstypen:
   1. symbolisch,
   2. geheel getal,
   3. enkele echte precisie,
   4. dubbele precisie echt.

Gedetailleerde beschrijving van gegevenstypen in SI-taal

type	Karaktertype	Type geheel getal	Echt type met enkele precisie	Echt type met dubbele precisie
beschrijving	verkoold	int	vlot	dubbele
maat	1 byte (8 bits)	4 bytes (32 bits)	4 bytes (32 bits) 23 bits – mantisse; 8 bits – bestelling; 1 bit – teken.	8 bytes (64 bits) 52 bits – mantisse; 11 bits – bestelling; 1 bit – teken.
bereik van waarden	-128 ... 127	2147483648 ... 2147483647	±3,4E±38 Nauwkeurigheid tot 7 decimalen	±1,7E±308 Nauwkeurigheid tot 17 decimalen

De SI-taal biedt twee soorten gegevenstypemodificatoren:
   1. tekenmodificatoren: ondertekend en niet-ondertekend.
   2. maataanpassingen: kort en lang.
  Typeaanpassers worden in meer detail beschreven in de tabel:

Complexe getallen in SI

  Complexe getallen werden geïntroduceerd in de C99-standaard.
   float_Complex
   dubbel_Complex
   lang dubbel_Complex
  Al dit geluk is om in de bibliotheek te zijn complex.h :)

Minimaal en maximale waarden alle basisgegevenstypen van de SI-taal worden beschreven in de bibliotheken: limit.h – bevat bereiken van gehele waarden, float.h – bevat bereiken van reële waarden.

Booleaans gegevenstype in SI

  Standaard C89:
  Booleaans type – int
    0 – onwaar;
    niet 0 – waar. Dat wil zeggen dat er geen logisch type als zodanig is gemaakt, maar dat in plaats daarvan int wordt gebruikt.
  Standaard C99:
   Booleaans type - _Bool
  Trefwoorden: bool waar onwaar
En dit is geluk in de bibliotheek stdbool.h

Operatoren voor aangifte

  Variabel – genoemd geheugengebied computer, ontworpen om waarden op te slaan bepaald type, met willekeurige toegangsmethode: lezen en schrijven. Variabelenaam is een geldige SI-taalidentificatie die niet eerder werd gebruikt om andere variabelen, typen, opsommingsleden of functienamen aan te duiden. De operator voor variabele declaratie heeft de volgende syntaxis: type naam1[,naam2[,...]]; Voorbeelden:
  int a, b, c;
  dubbele x, y;
  teken ch;  Er zijn enkele onuitgesproken regels, dat wil zeggen: uitvoering in goede vorm, maar het is niet nodig om dit te doen:
   1. elke declaratie van variabelen van een nieuw type begint op een nieuwe regel;
   2. uit de naam van de variabele moet duidelijk blijken waarom deze is en wat erin zal worden opgeslagen (hoewel soms door zulke informatieve namen de snelheid van het schrijven van code afneemt, omdat sommige mensen in de war raken en variabelen hele zinnen noemen);
   3. Daarom verschijnt de regel: de naam van de variabele mag niet te lang zijn;
   4. na het declareren van een variabele is het zeer raadzaam om in de opmerkingen aan te geven waarvoor deze dient;
   5. Het is noodzakelijk om namen van variabelen te scheiden met spaties.
  De operator voor variabele declaratie met initialisatie heeft de volgende syntaxis: type naam1[=waarde1][, naam2[=waarde2][,...]]; Voorbeelden:
  int a=26, b=032, c=0x1A;
  dubbel x=2,5e2,y=0x1.ffe-3;
  char ch=’Z’;

Constanten in SI

  Er zijn drie soorten constanten in de SI-taal:
   1. gehele getallen,
   2. echt,
   3. symbolisch.
  Gehele constanten
   1. De decimale constante wordt aangegeven decimale in de gebruikelijke vorm.
   2. Een octale constante wordt aangegeven door een getal dat begint met het cijfer nul en de cijfers 0...7 bevat.
   3. Een hexadecimale constante wordt aangegeven door een geheel getal met een voorvoegsel 0x of 0X, dat de cijfers 0...9 en de letters van het Latijnse alfabet a...f, A...F bevat.
  Echte constanten worden geschreven in decimalen of hexadecimaal systeem rekening. De positie van de komma wordt aangegeven met een punt, daarna wordt de exponent aangegeven Latijnse brief e (of E). Karakterconstanten voorafgegaan door een \-teken, dit is het zogenaamde "ontsnappen". Er zijn speciale tekens in SI:
   ‘\’’ – enkele aanhalingstekens,
   ‘\”’ – dubbele aanhalingstekens,
   ‘\\’ – backslash,
   ‘\?’ – vraagteken,
   ‘\a’ – geluidssignaal,
   ‘\b’ – een teken verwijderen,
   ‘\f’ – pagina scrollen,
   ‘\n’ – regelinvoer,
   ‘\r’ – regelterugkeer naar het begin van de regel,
   ‘\t’ – horizontaal tabblad,
   ‘\v’ – verticaal tabblad.

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

  De operator typedef wordt gebruikt om te creëren aangepaste typen data, de syntaxis voor het gebruik ervan: typedef oude_type_naam nieuwe_type_naam; Voorbeeld:
   typedef niet-ondertekend int woord;
  In SI kan typedefinitie volgens de standaard vrijwel overal in het programma worden uitgevoerd (dat wil zeggen dat er geen strikt gedefinieerd blok is voor het definiëren van gegevenstypen). , retourneert het het aantal bytes dat in het geheugen is ingenomen. Voorbeeld:
   sizeof(int) //return 4
   sizeof(char) //resultaat 1
   sizeof(dubbel) // retourneert 8