Laten we meer te weten komen over de gegevenstypen van de Pascal-taal: Integer, Real, Char, String, Boolean. Gegevenstypen voor geheel getal

in Pascal variabelen worden gekenmerkt door hun type... Een type is een eigenschap van een variabele, waardoor een variabele een verscheidenheid aan waarden kan aannemen die door dit type zijn toegestaan ​​en kan deelnemen aan een reeks bewerkingen die op een bepaald type zijn toegestaan.

Een type definieert de set geldige waarden die een variabele van een bepaald type aanneemt. Het definieert ook de reeks toegestane bewerkingen van een variabele van dit type en bepaalt de representatie van gegevens in het RAM van de computer.

Bijvoorbeeld:

n: geheel getal;

Pascal is een statische taal, hieruit volgt dat het type van een variabele tijdens de beschrijving wordt bepaald en niet kan worden gewijzigd. De Pascal-taal heeft een ontwikkeld systeem van typen - alle gegevens moeten behoren tot een eerder bekend gegevenstype (ofwel een standaardtype dat is gemaakt tijdens de ontwikkeling van de taal of een door de gebruiker gedefinieerd type dat is gedefinieerd door de programmeur). De programmeur kan zijn eigen typen maken met een willekeurige complexiteitsstructuur op basis van standaardtypen, of reeds door de gebruiker gedefinieerde typen. Het aantal aangemaakte typen is onbeperkt. Door de gebruiker gedefinieerde typen in het programma worden gedeclareerd in de sectie TYPE op formaat:

[naam] = [type]

Het systeem van standaardtypen heeft een vertakte, hiërarchische structuur.

Primair in de hiërarchie zijn eenvoudige soorten... Deze typen zijn te vinden in de meeste programmeertalen en worden eenvoudig genoemd, maar in Pascal hebben ze een complexere structuur.

Gestructureerde typen zijn gebouwd volgens bepaalde regels van eenvoudige typen.

wijzers zijn gevormd uit eenvoudige typen en worden in programma's gebruikt om adressen in te stellen.

Procedurele typen zijn nieuw voor Turbo Pascal, en ze laten toe dat subroutines als variabelen worden behandeld.

Voorwerpen zijn ook nieuw, en ze zijn ontworpen om de taal te gebruiken als een objectgeoriënteerde taal.

Er zijn 5 soorten integer-typen in Pascal. Elk van hen kenmerkt het bereik van geaccepteerde waarden en hun bezette geheugenruimte.

Bij het gebruik van gehele getallen moet u zich laten leiden door het nesten van typen, d.w.z. typen met een kleiner bereik kunnen worden genest binnen typen met een groter bereik. Het type Byte kan worden genest in alle typen die 2 en 4 bytes lang zijn. Tegelijkertijd kan het Short Int-type, dat 1 byte in beslag neemt, niet worden genest in het Word-type, omdat het geen negatieve waarden heeft.

Er zijn 5 echte typen:

In een computer worden integer-typen absoluut exact weergegeven. In tegenstelling tot integer-typen, definieert de waarde van reële typen een willekeurig getal alleen met enige eindige precisie, afhankelijk van het formaat van het getal. Reële getallen worden weergegeven in een computer met vaste of drijvende komma.

2358.8395

0.23588395*10 4

0.23588395 * E 4

Een speciale plaats in Pascal wordt ingenomen door het type Comp, in feite is het een groot getal met teken. Dit type is compatibel met alle reële typen en kan worden gebruikt voor grote gehele getallen. Bij het representeren van reële getallen met drijvende komma, wordt de komma altijd geïmpliceerd vóór de linker of hoge mantisse, maar wanneer het met een getal werkt, wordt het naar links of rechts verschoven.

Ordinale typen

Ordinale typen combineren verschillende eenvoudige typen. Deze omvatten:

• alle typen gehele getallen;
• karaktertype;
• booleaans type;
• bereiktype;
• opgesomde soort.

Gemeenschappelijke kenmerken voor ordinale typen zijn: elk type heeft een eindig aantal mogelijke waarden; de waarde van deze typen kan op een bepaalde manier worden geordend en aan elk nummer kan een bepaald getal worden gekoppeld, wat een ordinaal getal is; aangrenzende waarden van ordinale typen verschillen met één.

De functie ONEVEN (x) kan worden toegepast op waarden van het ordinale type, die het rangtelwoord van het argument x retourneert.

PRED (x) functie - Retourneert de vorige waarde van het ordinale type. PRED (A) = 5.

SUCC (x) functie - Retourneert de volgende waarde van het ordinale type. SUCC (A) = 5.

Karaktertype

De tekentypewaarden zijn 256 tekens uit de set die is toegestaan ​​door de codetabel van de computer die wordt gebruikt. Het startgebied van deze set, dat wil zeggen het bereik van 0 tot 127, komt overeen met de set ASCII-codes, waarin alfabettekens, Arabische cijfers en speciale tekens worden geladen. De tekens in het startgebied zijn altijd aanwezig op het pc-toetsenbord. Het seniorengedeelte wordt alternatief genoemd, het bevat symbolen van nationale alfabetten en verschillende speciale tekens, en pseudo-grafische symbolen die niet overeenkomen met de ASCII-code.

Een tekentypewaarde neemt één byte in RAM in beslag. In het programma staat de waarde tussen apostrofs. Ook kunnen waarden worden opgegeven in de vorm van de ASCII-code. In dit geval moet het #-teken voor het cijfer met de tekencode worden geplaatst.

C: = 'A'

Booleaans type

Er zijn twee Booleaanse waarden: True en False. Variabelen van dit type worden gespecificeerd met het BOOLEAN servicewoord. Booleaanse waarden nemen één byte in RAM in beslag. Waarden True en False komen overeen met de numerieke waarden 1 en 0.

Bereiktype:

Er is een subset van het basistype, dat elk ordinaal type kan zijn. Range-type wordt gedefinieerd door grenzen binnen het basistype.

[min-waarde] ... [max-waarde]

Het bereik-type kan worden gespecificeerd in de sectie Type als een specifiek type, of rechtstreeks in de sectie Var.

Bij het definiëren van een bereiktype moet u zich laten leiden door:

• de linkerrand mag de rechterrand niet overschrijden;
• range-type neemt alle eigenschappen van het basistype over, maar met beperkingen die verband houden met de lagere kardinaliteit.

opgesomd type

Dit type behoort tot ordinale typen en wordt gespecificeerd door een opsomming van die waarden die het kan opsommen. Elke waarde wordt genoemd door een identifier en bevindt zich in de lijst tussen haakjes. Een opgesomd type wordt gespecificeerd in Type:

Volkeren = (mannen, vrouwen);

De eerste waarde is 0, de tweede waarde is 1, enzovoort.

Maximaal vermogen 65535 waarden.

Stringtype

Het stringtype behoort tot de groep van gestructureerde typen en bestaat uit het basistype Char. Het stringtype is geen ordinaal type. Het definieert een reeks tekenreeksen van willekeurige lengte tot 255 tekens.

In het programma wordt het stringtype gedeclareerd door het woord String. Aangezien String een basistype is, wordt het beschreven in de taal en wordt een variabele van het type String gedeclareerd in Var. Bij het declareren van een variabele van een stringtype achter String, is het raadzaam om de lengte van de string tussen vierkante haken aan te geven. Een geheel getal van 0 tot 255 wordt gebruikt om aan te geven.

Fam: String;

Door de stringlengte op te geven, kan de compiler een gespecificeerd aantal bytes in RAM toewijzen aan de variabele. Als de stringlengte niet is opgegeven, zal de compiler het maximaal mogelijke aantal bytes (255) toewijzen aan de waarde van deze variabele.

Pascal-gegevenstypen: classificatie en beschrijving. Rekenkundige en ordinale gegevenstypen, bewerkingen ermee. Rekenkundige uitdrukkingen: functies, bewerkingen en volgorde van acties. Compatibiliteit van gegevenstypes en conversies.

Pascal-compilers vereisen dat informatie over de hoeveelheid geheugen die nodig is om een ​​programma uit te voeren, wordt verstrekt voordat het wordt uitgevoerd. Om dit te doen, in de sectie die variabelen beschrijft ( var) moet u een lijst maken van alle variabelen die in het programma worden gebruikt. Bovendien moet u de compiler ook vertellen hoeveel geheugen elk van deze variabelen in beslag zal nemen. En het zou ook leuk zijn om vooraf afspraken te maken over de verschillende bewerkingen die van toepassing zijn op bepaalde variabelen ...

Dit alles kan aan het programma worden gecommuniceerd door eenvoudig het type van de toekomstige variabele op te geven. Met informatie over het type variabele "begrijpt" de compiler hoeveel bytes eraan moeten worden toegewezen, welke acties ermee kunnen worden uitgevoerd en in welke constructies hij kan deelnemen.

Voor het gemak van programmeurs in de Pascal-taal zijn er veel standaard datatypes, plus de mogelijkheid om nieuwe types te creëren.

Bij het construeren van nieuwe datatypes op basis van bestaande (standaard of, nogmaals, gedefinieerd door de programmeur zelf), moet men bedenken dat elk gebouw op een goede basis moet worden gebouwd. Daarom zullen we het nu hebben over deze "basis".

gebaseerd basisgegevenstypen alle andere typen van de Pascal-taal zijn gebouwd, die zo worden genoemd: gebouwd.

De indeling in basis- en geconstrueerde datatypes in Pascal is weergegeven in de tabel:

Door de programmeur geconstrueerde gegevenstypen worden beschreven in de sectie: type volgens het volgende patroon:

type<имя_типа> = <описание_типа>;

Bijvoorbeeld:

typ Lat_Bukvy = "a" .. "z", "A" .. "Z";

Basisgegevenstypen zijn standaard, dus het is niet nodig om ze in de sectie te beschrijven type... Desgewenst kan dit echter ook door bijvoorbeeld lange definities te geven korte namen... Laten we zeggen door een nieuw gegevenstype te introduceren

typ Int = geheel getal;

je kunt de tekst van het programma iets inkorten.

Standaard gebouwde typen hoeven ook niet in de sectie te worden beschreven: type... In sommige gevallen moet dit echter nog worden gedaan vanwege syntaxisvereisten. Bijvoorbeeld, in parameterlijst: procedures of functies type constructors kunnen niet worden gebruikt (zie. College 8).

Ordinale gegevenstypen

Onder de basisgegevenstypen, ordinale typen... Deze naam kan op twee manieren worden gerechtvaardigd:

Standaard routines verwerking ordinale gegevenstypen

Alleen voor hoeveelheden ordinale typen de volgende functies en procedures zijn gedefinieerd:

1. Functie Ord(x) geeft het rangtelwoord van de waarde van de variabele x (ten opzichte van het type waartoe de variabele x behoort).
2. Functie Pred(x) geeft de waarde vóór x terug (niet van toepassing op het eerste element van het type).
3. Functie Succ(x) geeft de waarde na x terug (niet van toepassing op het laatste element van het type).
4. Procedure inclusief(x) retourneert de waarde die volgt op x (for rekenkundige gegevenstypen dit komt overeen met de operator x: = x + 1).
5. Procedure inclusief(x, k) retourneert de kde waarde volgend op x (for rekenkundige gegevenstypen dit komt overeen met de operator x: = x + k).
6. Procedure december(x) geeft de waarde terug die voorafgaat aan x (for rekenkundige gegevenstypen dit komt overeen met de operator x: = x - 1).
7. Procedure december(x, k) geeft de k – e waarde voorafgaand aan x terug (for rekenkundige gegevenstypen dit komt overeen met de operator x: = x - k).

Op het eerste gezicht lijkt het resultaat van de toepassing van de procedure inclusief(x) komt volledig overeen met het resultaat van het gebruik van de functie Succ(x)... Het verschil tussen hen verschijnt echter aan de grenzen van het toegestane bereik. Functie Succ(x) is niet van toepassing op het maximale lid van het type, maar de procedure is: inclusief(x) zal geen fout geven, maar zal, handelend volgens de regels van de machinetoevoeging, de volgende eenheid aan het elementnummer toevoegen. Het nummer valt natuurlijk buiten het bereik en zal door afknotting veranderen in het nummer van de minimumwaarde van het bereik. Het blijkt dat de procedures inclusief() en december() ze nemen elk ordinaal type waar als "gesloten in een ring": onmiddellijk na de laatste komt weer de eerste waarde.

Laten we alles wat is gezegd uitleggen met een voorbeeld. Voor gegevenstype:

type Zestien = 0 .. 15;

proberen om 1 tot 15 toe te voegen, levert het volgende resultaat op:

1 1 1 1 1 1 0 0 0 0

De initiële eenheid wordt afgekapt en daarom zal blijken dat: inclusief(15)=0 .

Een vergelijkbare situatie aan de ondergrens van het toegestane bereik van een willekeurig ordinaal gegevenstype wordt waargenomen voor de procedure december(x) en functies Pred(x):

Gegevenstypen gerelateerd aan: ordinaal

Laten we het nu beschrijven ordinale gegevenstypen in detail.

1. Booleaans type Booleaans heeft twee betekenissen, False en True, en de volgende gelijkheden gelden voor hen:
2. In karaktertype Char bevat 256 tekens uitgebreide ASCII-tabel(bijvoorbeeld "a", "b", "i", "7", "#"). Het tekennummer dat door de functie wordt geretourneerd Ord() , komt overeen met het nummer van dit teken in ASCII-tabel.
3. Gegevenstypen voor geheel getal laten we samenvatten in de tabel:
4. opgesomd gegevenstypen worden ingesteld in de sectie type een expliciete lijst van hun elementen. Bijvoorbeeld:

   type Week = (zo, ma, di, wo, do, vr, za); 0 1 2 3 4 5 6

   Bedenk dat voor dit gegevenstype:

5. Intervalgegevenstypen worden alleen bepaald door de grenzen van hun bereik. Bijvoorbeeld:

   type maand = 1 .. 12;
   Budni = ma .. vr;

6. De programmeur kan zijn eigen datatypes creëren, die een combinatie zijn van verschillende standaardtypes. Bijvoorbeeld:

   typ Valid_For_Identifiers = "a" .. "z", "A" .. "Z", "_", "0" .. "9";

Dit type bestaat uit het combineren van verschillende intervallen, en in dit geval wordt de volgorde van de Latijnse letters gewijzigd: als in het standaardtype

Federaal Agentschap voor Onderwijs

abstract

"GEGEVENSTYPEN IN PASCAL"

1. Gegevenstypen

Alle gegevens, d.w.z. constanten, variabelen, eigenschappen, functiewaarden of uitdrukkingen worden gekenmerkt door hun type. Een type definieert de set geldige waarden die een object kan hebben, evenals de set geldige bewerkingen die erop van toepassing zijn. Daarnaast bepaalt het type ook het formaat van de interne weergave van gegevens in het pc-geheugen.

Over het algemeen wordt de Object Pascal-taal gekenmerkt door een vertakte structuur van gegevenstypen (Fig. 1.1). De taal biedt een mechanisme voor het maken van nieuwe typen, waardoor het totale aantal typen dat in het programma wordt gebruikt zo groot kan zijn als gewenst.

De gegevens die in het programma worden verwerkt, zijn onderverdeeld in variabelen, constanten en letterlijke waarden:

constanten zijn gegevens waarvan de waarden zijn ingesteld in de constante declaratiesectie en niet veranderen tijdens de uitvoering van het programma.

Variabelen worden gedeclareerd in de sectie variabele declaratie, maar in tegenstelling tot constanten ontvangen ze hun waarden al tijdens de uitvoering van het programma en deze waarden kunnen worden gewijzigd. Constanten en variabelen zijn toegankelijk op naam.

letterlijke heeft geen identifier en wordt in de programmatekst direct vertegenwoordigd door de waarde.

Een type definieert de reeks waarden die gegevenselementen kunnen aannemen en de reeks bewerkingen die daarop zijn toegestaan.

In dit en de volgende vier hoofdstukken worden alle typen uitgebreid beschreven.

1.1 Eenvoudige typen

Eenvoudige typen omvatten ordinale typen, reële typen en datum-tijd typen.

Ordinale typen verschillen doordat elk van hen een eindig aantal mogelijke waarden heeft. Deze waarden kunnen op een bepaalde manier worden gerangschikt (vandaar de naam van de typen) en daarom kan elk van hen worden geassocieerd met een geheel getal - het rangtelwoord van de waarde.

Echte typen hebben strikt genomen ook een eindig aantal waarden, dat wordt bepaald door het formaat van de interne representatie van een reëel getal. Het aantal mogelijke waarden van echte typen is echter zo groot dat het niet mogelijk is om een ​​geheel getal (zijn aantal) aan elk van hen te koppelen.

Datum-tijdtype bedoeld voor het opslaan van datum en tijd. In feite gebruikt het voor deze doeleinden een echt formaat.

1.1.1 Ordinale typen

Ordinale typen omvatten (zie figuur 1.1) integer, boolean, karakter, enumerated en range-type. De functie Ord (x) is van toepassing op elk van hen, die de ordinale waarde van de uitdrukking X retourneert.

Rijst. 1.1 - Gegevenstypestructuur

Voor geheel van typen, retourneert de functie ord (x) de waarde van x zelf, dat wil zeggen Ord (X) = x voor x behorend tot een willekeurig geheel type. Bestelling (x) toepassen op logisch , symbolisch en opsombaar typen geeft een positief geheel getal in het bereik van 0 tot 1 ( booleaans type), van 0 tot 255 ( symbolisch), van 0 tot 65535 ( opsombaar). Bereiktype: behoudt alle eigenschappen van het basisordinale type, dus het resultaat van het toepassen van de ordinale functie erop hangt af van de eigenschappen van dit type.

U kunt ook functies toepassen op ordinale typen:

pred (x)- geeft de vorige waarde van het rangtelwoordtype terug (de waarde die overeenkomt met het rangtelwoord ord (x) -1, dat wil zeggen, оrd (рred (х)) = оrd (х) - 1;

succ (x)- geeft de volgende waarde van het ordinale type terug, die overeenkomt met ordinaal getal ord (х) +1, d.w.z. оrd (Succ (х)) = оrd (х) + 1.

Als het programma bijvoorbeeld de variabele definieert

dan retourneert de PRED (c)-functie het teken "4", en de SUCC (c)-functie retourneert het teken "6".

Als we ons een ordinaal type voorstellen als een geordende reeks waarden die van links naar rechts toenemen en een bepaald segment op de numerieke as innemen, dan is de pred (x) -functie niet gedefinieerd voor links, en succ (x) - voor het rechter uiteinde van dit segment.

Integer typen ... Het bereik van mogelijke waarden voor integer-typen hangt af van hun interne representatie, die één, twee, vier of acht bytes kan zijn. Tafel 1.1 vermeldt de namen van integer-typen, de lengte van hun interne representatie in bytes en het bereik van mogelijke waarden.

Tabel 1.1 - Gehele typen

Soorten LangWoord en Int64 werden voor het eerst geïntroduceerd in versie 4, en de typen Smallint en Kardinaal niet beschikbaar in Delphi 1. Type geheel getal voor deze versie duurt het 2 bytes en heeft het een bereik van waarden van -32768 tot +32767, dat wil zeggen, het is hetzelfde als Smallint .

Bij het gebruik van procedures en functies met integer-parameters, moet men zich laten leiden door het "nesten" van typen, dwz. waar het ook kan worden gebruikt woord, gebruik is toegestaan Byte(maar niet andersom), in Longint"Inbegrepen" Smallint die op zijn beurt omvat: Shortint .

De lijst met procedures en functies die van toepassing zijn op typen integers wordt gegeven in de tabel. 1.2. De letters b, s, w, i, l duiden respectievelijk uitdrukkingen aan van het type Byte , Shortint, Word, Integer en Longint ,

x is een uitdrukking van elk van deze typen; de letters vb, vs, vw, vi, vl, vx duiden variabelen van de overeenkomstige typen aan. Een optionele parameter wordt tussen vierkante haken aangegeven.

Tabel 1.2 - Standaardprocedures en -functies die van toepassing zijn op typen gehele getallen

Voor bewerkingen met gehele getallen komt het type resultaat overeen met het type operanden, en als de operanden van verschillende typen integers zijn, het algemene type, dat beide operanden omvat. Als je bijvoorbeeld handelt met shortint en woord gemeenschappelijk zal het type zijn geheel getal... In de standaardinstelling genereert de Delphi-compiler geen code die de mogelijkheid controleert om te controleren of een waarde buiten het bereik ligt, wat tot verwarring kan leiden.

Booleaanse typen ... Booleaanse typen omvatten: Boolean, ByteBool, Bool, wordBool en LongBool... In standaard Pascal wordt alleen het type gedefinieerd Booleaans, de rest van de booleaanse typen zijn geïntroduceerd in Object Pascal voor compatibiliteit met Windows: typen Booleaans en ByteBool bezetten elk één byte, Bool en WordBool- 2 bytes elk, LongBool- 4 bytes. Booleaanse waarden kunnen een van de eerder gedeclareerde constanten False of True zijn.

Aangezien het booleaanse type een ordinaal type is, kan het worden gebruikt in een lusoperator van een aftelbaar type. In Delphi 32 voor Booleaans betekenis

Ord (True) = +1, terwijl voor andere typen ( Bool, WordBool enzovoort.)

Ord (True) = -1, dus dit soort operator moet met zorg worden gebruikt! Bijvoorbeeld, voor Delphi 6, de uitvoerbare instructie showMessage ("---") in de volgende lus voor wordt niet één keer uitgevoerd:

voor L: = Onwaar naar Waar do

Toon bericht ("-);

Als we het type van de lusparameter L in het vorige voorbeeld vervangen door Booleaans, wordt de cyclus uitgevoerd en verschijnt het bericht twee keer op het scherm. [Voor Delphi-versie 1 en 2, ord (True) = + 1 voor elk booleaans type.]

Karaktertype ... Karaktertype-waarden zijn de set van alle pc-tekens. Aan elk teken wordt een geheel getal in het bereik 0 ... 255 toegewezen. Dit nummer dient als de code voor de interne representatie van het symbool en wordt geretourneerd door de ordenfunctie.

Windows gebruikt de ANSI-code voor codering (genoemd naar het American National Standard Institute - het American Standards Institute dat deze code heeft voorgesteld). De eerste helft van de pc-tekens met codes 0 ... 127 komt overeen met tabel 1.3. De tweede helft van tekens met codes 128 ... 255 varieert voor verschillende lettertypen. Standaard Windows-lettertypen Arial Cyr, Courier New Cyr en Times New Roman om Cyrillische tekens weer te geven (zonder de letters "ё" en "Ё") gebruiken de laatste 64 codes (van 192 tot 256): "A" ... "Z" zijn gecodeerde waarden ​​192..223, "a" ... "i" - 224 ... 255. De symbolen "Ё" en "ё" hebben respectievelijk de codes 168 en 184.

Tabel 1.3 - Tekencodering volgens de ANSI-standaard

Symbolen met codes 0 ... 31 verwijzen naar servicecodes. Als deze codes worden gebruikt in de tekentekst van het programma, worden ze als spaties beschouwd.

Typen char relatiebewerkingen zijn van toepassing, evenals ingebouwde functies:

har (in)- functioneren als char; converteert uitdrukking naar type Byte naar een symbool en retourneert het met zijn waarde;

UpCase (CH)- functioneren als char; geeft een hoofdletter terug als ch een kleine Latijnse letter is, anders wordt het teken ch geretourneerd (voor Cyrillisch wordt het oorspronkelijke teken geretourneerd).

opgesomd type ... Een opgesomd type wordt gespecificeerd door een opsomming van de waarden die het kan ontvangen. Elke waarde wordt genoemd door een identifier en bevindt zich in een lijst tussen haakjes, bijvoorbeeld:

kleuren = (rood, wit, blauw);

Het gebruik van opgesomde typen maakt programma's overzichtelijker.

De overeenkomst tussen de waarden van het opgesomde type en de rangtelwoorden van deze waarden wordt bepaald door de opsommingsvolgorde: de eerste waarde in de lijst krijgt rangtelwoord 0, de tweede - 1, enzovoort. een opgesomd type is 65536 waarden, daarom specificeert een opgesomd type in feite een subset van het integer-type woord en kan worden beschouwd als een compacte declaratie van een groep geheeltallige constanten met waarden 0, 1, enz.

Het gebruik van opgesomde typen verhoogt de betrouwbaarheid van programma's vanwege de mogelijkheid om de waarden te regelen die de bijbehorende variabelen ontvangen. De omgekeerde conversie is toegestaan ​​in Object Pascal: elke uitdrukking van het type Woord kan worden geconverteerd naar een opgesomde waarde zolang de waarde van de integer-expressie de kardinaliteit van dat type niet overschrijdt. Deze conversie wordt bereikt door een automatisch gedeclareerde functie te gebruiken met de naam van een opgesomd type.

Bereiktype: ... Bereiktype is een subset van het basistype, dat elk ander ordinaal type kan zijn dan bereiktype.

Het bereiktype wordt bepaald door de grenzen van zijn waarden binnen het basistype:

<мин.знач.>..<макс.знач.>

Hier<мин. знач. >- de minimumwaarde van het range-type;<макс. знач. >- zijn maximale waarde.

Het bereiktype hoeft niet te worden beschreven in de typesectie, maar kan direct worden opgegeven bij het declareren van een variabele.

Bij het definiëren van een bereiktype moet u zich laten leiden door de volgende regels:

twee ".."-tekens worden als één teken behandeld, dus er mogen geen spaties tussen staan; de linkerrand van het bereik mag de rechterrand niet overschrijden.

Een bereiktype erft alle eigenschappen van het basistype, maar met beperkingen vanwege de lagere kardinaliteit. In het bijzonder als een variabele is gedefinieerd.

De standaardbibliotheek van Object Pascal bevat twee functies die het werken met bereiktypen ondersteunen:

Hoog (x)- geeft de maximale waarde terug van het bereik-type waartoe de variabele x behoort;

Laag (x)- retourneert de minimumwaarde van het bereiktype.

1.1.2 Echte typen

In tegenstelling tot ordinale typen, waarvan de waarden altijd worden vergeleken met een aantal gehele getallen en daarom absoluut exact in de pc worden weergegeven, definiëren de waarden van reële typen een willekeurig getal slechts met enige eindige precisie, afhankelijk van de interne formaat van het reële getal.

Tabel 1.4 - Echte typen

In eerdere versies van Delphi 1 ... 3 type Echt nam 6 bytes in beslag en had een bereik van waarden van 2,9 * 10-39 tot 1,7 * 1038. In versies 4 en 5 is dit type gelijk aan het type Dubbele... Gebruik indien nodig (om compatibiliteitsredenen) 6-byte Echt, moet u de compilerrichtlijn opgeven (SREALCOMPATIBILITY ON).

Zoals je aan de tafel kunt zien. 1.4, een reëel getal in Object Pascal beslaat 4 tot 10 aaneengesloten bytes en heeft de volgende structuur in het pc-geheugen.

Hier is s het ondertekende cijfer van het nummer; e - exponentieel deel; bevat binaire volgorde; m is de mantisse van het getal.

Mantisse m heeft een lengte van 23 (for enkel) tot 63 (voor Verlengd) van binaire cijfers, wat zorgt voor een nauwkeurigheid van 7 ... 8 voor enkel en 19 ... 20 voor Verlengd decimale cijfers. De decimale punt (komma) wordt geïmpliceerd vóór het linker (meest significante) bit van de mantisse, maar bij het manipuleren van een getal wordt de positie naar links of rechts verschoven in overeenstemming met de binaire volgorde van het getal dat is opgeslagen in het exponentiële deel, daarom worden bewerkingen op reële getallen drijvende-kommaberekeningen (komma) genoemd ...

Merk op dat de rekenkundige coprocessor altijd getallen verwerkt in het formaat Verlengd, en de andere drie reële typen worden in dit geval verkregen door de resultaten eenvoudigweg af te kappen tot de gewenste grootte en worden voornamelijk gebruikt om geheugen te besparen.

Types nemen een speciale plaats in in Object Pascal. compa en Munteenheid, die worden behandeld als reële getallen met fractionele delen van vaste lengte: in compa het fractionele deel heeft een lengte van 0 cijfers, dat wil zeggen, het is gewoon afwezig, in munteenheid de lengte van het breukdeel is -4 decimalen. In feite definiëren beide typen een groot geheel getal met teken dat 19 ... 20 significante decimale cijfers opslaat (intern nemen ze 8 aaneengesloten bytes in beslag). Tegelijkertijd, in uitdrukkingen compa en munteenheid zijn volledig compatibel met andere reële typen: alle reële bewerkingen worden erover gedefinieerd, ze kunnen worden gebruikt als argumenten van wiskundige functies, enz. Het meest geschikte toepassingsgebied van deze typen zijn boekhoudkundige berekeningen.

1.1.3 Datum-tijdtype

Het datum-tijdtype wordt bepaald door een standaard-ID TDateTime en is bedoeld voor gelijktijdige opslag van zowel datum als tijd. In de interne representatie neemt het 8 bytes in beslag en is vergelijkbaar munteenheid is een reëel getal met een vast breukdeel: de datum wordt opgeslagen in het gehele deel van het getal en de tijd wordt opgeslagen in het breukdeel. De datum wordt gedefinieerd als het aantal dagen dat is verstreken sinds 30 december 1899, en de tijd wordt gedefinieerd als een fractie van de dag sinds 0 uur, dus de waarde 36444.837 komt overeen met de datum 10/11/1999 en de tijd 20:05. Het aantal dagen kan negatief zijn, maar waarden kleiner dan -693594 (overeenkomend met de datum 00.00.0000 van de Geboorte van Christus) worden genegeerd door de conversiefuncties van datum naar string.

Bovenstaande gegevens zoals TDateTime dezelfde bewerkingen worden gedefinieerd als bij reële getallen, en constanten en variabelen van integer en reëel typen kunnen deelnemen aan uitdrukkingen van dit type.

sinds het type TDateTime compatibel met het formaat van reële getallen, kunt u gemakkelijk de datum bepalen die enkele dagen voor of achter de gegeven datum ligt: ​​hiervoor volstaat het om respectievelijk het gewenste gehele getal op te tellen bij of af te trekken van de gegeven datum.

1.2 Gestructureerde typen

Elk van de gestructureerde typen (en in Object Pascal zijn er vier: arrays, records, sets en bestanden) wordt gekenmerkt door de veelheid aan elementen die dit type vormen. Elk element kan op zijn beurt tot een gestructureerd type behoren, wat ons in staat stelt te praten over de mogelijke nesting van typen. Object Pascal staat willekeurige nestdiepte van typen toe, maar de totale lengte van elk van hen in de interne weergave mag niet groter zijn dan 2 GB.

Voor compatibiliteit met standaard Pascal mag Object Pascal voorafgaan aan een gestructureerde typedeclaratie met een gereserveerd woord Ingepakt, de compiler instrueren om het geheugen dat is toegewezen aan objecten van het gestructureerde type zoveel mogelijk op te slaan; maar de compiler negeert deze hint eigenlijk: het "verpakken" van gegevens in Object Pascal gebeurt waar mogelijk automatisch.

1.2.1 Arrays

Arrays in Object Pascal lijken erg op vergelijkbare gegevenstypen in andere programmeertalen. Een onderscheidend kenmerk van arrays is dat al hun componenten gegevens van hetzelfde type zijn (eventueel gestructureerd). Deze componenten kunnen eenvoudig worden besteld en alle zijn toegankelijk door eenvoudig het serienummer op te geven.

Een beschrijving van het arraytype wordt als volgt gedefinieerd:

<имя типа>= reeks [<сп.инд.типов>] van<тип>;

Hier<имя типа>- juiste identificatie; reeks, van- gereserveerde woorden (array, from);<сп.инд.типов>- een lijst met een of meer indextypen, gescheiden door komma's; vierkante haken rond de lijst zijn een syntaxisvereiste;<тип>- elk type object Pascal.

Als indextypen in Object Pascal kunt u alle ordinale typen gebruiken die een kardinaliteit hebben van niet meer dan 2 GB (dat wil zeggen, behalve LangWoord en Int64)

De nestdiepte van gestructureerde typen in het algemeen, en bijgevolg van arrays, is willekeurig, dus het aantal elementen in de lijst met indextypen (arraydimensie) is niet beperkt, maar de totale lengte van de interne representatie van een array kan niet groter zijn dan 2 GB. In het pc-geheugen volgen array-elementen elkaar op, zodat bij het verplaatsen van lagere adressen naar hogere adressen de meest rechtse index van de array het snelst verandert.

In Object Pascal kun je met één toewijzingsoperator alle elementen van een array doorgeven aan een andere array van hetzelfde type.

1.2.2 Gegevens

Opnemen is een datastructuur die bestaat uit een vast aantal componenten, recordvelden genaamd. In tegenstelling tot een array kunnen de componenten (velden) van een record van verschillende typen zijn. Om het mogelijk te maken om naar een bepaald onderdeel van het record te verwijzen, worden de velden benoemd.

De structuur van de declaratie van het recordtype is als volgt:

<имятипа>= opnemen<сп.полей>einde;

Hier<имя типа>- juiste identificatie; opnemen / beëindigen- gereserveerde woorden (record, end);<сп.полей>- lijst met velden; is een reeks secties van een record met een puntkomma ertussen.

Elke sectie van een record bestaat uit een of meer veld-ID's, gescheiden door komma's.

Zin sprake van, waarmee het variantgedeelte wordt geopend, lijkt op de bijbehorende selectie-operator, maar speelt in feite alleen de rol van een soort servicewoord dat het begin van het variantgedeelte aangeeft. Daarom moet u aan het einde van het variantgedeelte niet plaatsen einde als koppel sprake van... (Omdat het variantgedeelte altijd het laatste in het record is, wordt het nog steeds gevolgd door het einde, maar alleen als een paar om op te nemen). Selectiesleutel in het voorstel sprake van wordt eigenlijk genegeerd door de compiler: de enige vereiste in Object Pascal is dat de sleutel een standaard of vooraf gedeclareerd ordinaal type definieert.

Veldnamen moeten uniek zijn binnen het record waar ze zijn gedeclareerd, maar als records recordvelden bevatten, dat wil zeggen dat ze in elkaar genest zijn, kunnen de namen op verschillende nestniveaus worden herhaald.

1.2.3 Sets

de sets zijn sets van hetzelfde type objecten die logisch met elkaar zijn verbonden. De aard van de verbindingen tussen objecten wordt alleen geïmpliceerd door de programmeur en wordt op geen enkele manier gecontroleerd door Object Pascal. Het aantal elementen in de set kan variëren van 0 tot 256 (een set die geen elementen bevat, wordt leeg genoemd). Het is de inconsistentie van het aantal van hun elementen die sets verschillen van arrays en records.

Twee verzamelingen worden als gelijkwaardig beschouwd als en slechts dan als al hun elementen hetzelfde zijn en de volgorde van de elementen in de verzameling onverschillig is. Als alle elementen van de ene verzameling ook in een andere verzameling zitten, spreken ze van de opname van de eerste verzameling in de tweede. Een lege set is inbegrepen in een andere.

De beschrijving van het settype is als volgt:

<имя типа>= set van<базовый тип>;

Hier<имя типа>- juiste identificatie; set, van- gereserveerde woorden (set, from);<базовый тип>- het basistype van de elementen van de set, die elk ordinaal type kan zijn, behalve Woord, Integer, Longint, Int64 .

Om een ​​set te definiëren wordt de zogenaamde setconstructor gebruikt: een lijst met specificaties van de setelementen, van elkaar gescheiden door komma's; de lijst is omgeven door vierkante haken. Elementspecificaties kunnen constanten of uitdrukkingen van een basistype zijn, evenals een bereiktype van hetzelfde basistype.

De interne structuur van de set is zodanig dat aan elk van zijn elementen één binair cijfer (één bit) wordt toegewezen; als het element in de set is opgenomen, heeft de corresponderende bit de waarde 1, anders - 0. Tegelijkertijd is de minimale geheugeneenheid één byte met 8 bits, dus de compiler heeft één byte aan de sets toegewezen, en als een resultaat, de kardinaliteit van elk van hen werd 8 elementen. De maximale kardinaliteit van een verzameling is 256 elementen. Voor dergelijke sets wijst de compiler 16 aaneengesloten bytes toe.

En nog een experiment: verander het bereik van het basistype in 1..256. Hoewel de kardinaliteit van dit type 256 elementen is, zal de compiler bij het compileren van het programma een fout rapporteren: Sets mogen maximaal 256 elementen hebben (Sets mogen niet meer dan 256 elementen hebben) sinds de nummering van de elementen van de set begint vanaf nul, ongeacht de ondergrens die in het programma is aangegeven ... De compiler maakt het mogelijk om als basistype een integer-bereiktype te gebruiken met een minimale grens van 0 en een maximum van 255, of elk opgesomd type met niet meer dan 256 elementen (de maximale kardinaliteit van een opgesomd type is 65536 elementen).

1.3 Snaren

De volgende typen worden gebruikt voor tekstverwerking in Object Pascal:

korte lijn korte string of tekenreeks [n] waar n<= 255;

lange rij snaar ;

brede snaar WideString ;

null-beëindigde string pchar .

Wat deze typen gemeen hebben, is dat elke string wordt behandeld als een eendimensionale reeks karakters, waarvan het aantal karakters kan veranderen in een lopend programma: voor string [n] varieert de lengte van de string van 0 tot n , voor snaar en pchar- van 0 tot 2 GB.

Standaard Pascal gebruikt alleen korte snaren Tekenreeks [n]... In het geheugen wordt aan een dergelijke string n + i bytes toegewezen, de eerste byte bevat de huidige lengte van de string en de tekens zelf worden gelokaliseerd vanaf de 2e byte. Aangezien in dit geval één byte wordt toegewezen voor de lengte van de string, mag de maximale lengte van een korte string niet langer zijn dan 255 tekens. Om een ​​korte string van maximale lengte te declareren, is het standaardtype bedoeld korte string(equivalent Snaar).

Windows gebruikt op grote schaal null-terminated strings, dit zijn tekenreeksen die worden gescheiden door het teken # o. De maximale lengte van zo'n string wordt alleen beperkt door het beschikbare geheugen en kan erg groot zijn.

Delphi 32-bit introduceert een nieuw type snaar het combineren van de gemakken van beide typen. Bij het werken met dit type wordt geheugen naar behoefte toegewezen (dynamisch) en wordt het beperkt door het beschikbare geheugen voor het programma.

1.4 Aanwijzers en heapgeheugen

1.4.1 Dynamisch geheugen

Dynamisch geheugen- dit is het pc-RAM dat aan het programma wordt geleverd wanneer het wordt uitgevoerd. Dynamische toewijzing van gegevens betekent het gebruik van dynamisch geheugen direct terwijl het programma draait. Statische toewijzing wordt daarentegen gedaan door de Object Pascal-compiler tijdens het compileren van het programma. Bij dynamische toewijzing is vooraf noch het type noch de hoeveelheid toe te wijzen gegevens bekend.

1.4.2 Aanwijzingen

PC RAM is een verzameling cellen voor het opslaan van informatie - bytes, die elk een eigen nummer hebben. Deze nummers worden adressen genoemd, ze geven u toegang tot elke byte van het geheugen. Object Pascal biedt de programmeur een flexibele tool voor het beheer van heap-geheugen - de zogenaamde pointers. Een pointer is een variabele die het geheugenbyte-adres als waarde bevat. Met behulp van aanwijzers kunt u alle bekende gegevenstypen in Object Pascal in heap toewijzen. Slechts een paar van hen ( Byte, Char, ShortInt, Boolean) bezetten één byte in de interne representatie, de rest - verschillende aaneengesloten. Daarom adresseert de aanwijzer in feite alleen de eerste byte aan gegevens.

Meestal wordt een aanwijzer geassocieerd met een bepaald type gegevens. We zullen dergelijke verwijzingen getypt noemen. Om een ​​getypte aanwijzer te declareren, gebruikt u het ^-symbool, dat voor het corresponderende type wordt geplaatst.

In Object Pascal kunt u een aanwijzer declareren en deze niet aan een bepaald gegevenstype binden. Hiervoor wordt het standaard type gebruikt. wijzer, Bijvoorbeeld:

Dergelijke pointers worden untyped genoemd. Aangezien pointers zonder type niet aan een specifiek type zijn gekoppeld, is het handig om ze te gebruiken om dynamisch gegevens toe te wijzen, waarvan de structuur en het type veranderen in de loop van het programma.

Zoals eerder vermeld, zijn de waarden van pointers de adressen van variabelen in het geheugen, dus je zou verwachten dat de waarde van de ene pointer kan worden doorgegeven aan de andere. In feite is dit niet waar. In Object Pascal kunt u alleen waarden doorgeven tussen aanwijzers die aan hetzelfde gegevenstype zijn gekoppeld.

1.4.3 Dynamisch geheugen toewijzen en vrijmaken

Al het heapgeheugen in Object Pascal wordt behandeld als een solide reeks bytes die een heap wordt genoemd.

Geheugen voor elke dynamisch toegewezen variabele wordt toegewezen door de nieuwe procedure. De parameter om deze procedure aan te roepen is een getypte aanwijzer. Als resultaat van de oproep krijgt de aanwijzer een waarde die overeenkomt met het adres van waaruit de gegevens kunnen worden geplaatst. De waarde waarnaar de aanwijzer verwijst, dat wil zeggen de feitelijke gegevens die op de heap zijn toegewezen, worden aangegeven met het ^-symbool, dat onmiddellijk na de aanwijzer wordt geplaatst. Als er geen ^-symbool achter de aanwijzer staat, betekent dit het adres waar de gegevens zich bevinden. Het is logisch om nog eens na te denken over wat zojuist is gezegd: de waarde van elke aanwijzer is een adres, en om aan te geven dat we het niet over een adres hebben, maar over de gegevens die zich op dit adres bevinden, wordt een ^ achter de aanwijzer (soms wordt dit de verwijzingsaanwijzer genoemd).

Dynamisch toegewezen gegevens kunnen overal in het programma worden gebruikt waar het is toegestaan ​​voor constanten en variabelen van het juiste type

Dynamisch geheugen kan niet alleen van de hoop worden gehaald, maar ook weer worden teruggegeven. Hiervoor wordt de procedure Dispose gebruikt. Bijvoorbeeld, de operators

Gooi weg (pJ);

Gooi weg (pR);

zal terugkeren naar de heap van het geheugen dat eerder was toegewezen aan de pJ- en pR-aanwijzers (zie hierboven).

Houd er rekening mee dat de procedure Dispose (pPtr) de waarde van de pPtr-aanwijzer niet verandert, maar alleen het geheugen dat eerder aan deze aanwijzer was gekoppeld, terugstuurt naar de heap. Het opnieuw toepassen van de procedure op een vrije aanwijzer zal echter resulteren in een runtime-fout. De programmeur kan de vrijgekomen aanwijzer markeren met het gereserveerde woord nul.

1.5 Typ aliassen

Voor elk type kunt u zoveel aliassen declareren als u wilt. Bijvoorbeeld:

TMijnGeheel getal = geheel getal;

In de toekomst kan de alias op dezelfde manier worden gebruikt als het basistype:

Mylnt: TMijnGeheel getal;

Mylnt: = 2 * Rond (pi);

Dit soort aliassen worden vaak gebruikt om de code leesbaarder te maken. In Object Pascal kunt u echter sterk getypte aliassen declareren door het gereserveerde woordtype voor de naam van het basistype toe te voegen:

TMyIntegerType = typ Integer;

MylntVar: TMyIntegerType;

Vanuit het oogpunt van de compiler zijn getypte aliassen compatibel met het basistype in verschillende soorten expressies, maar in feite declareren ze een nieuw gegevenstype, zodat ze niet kunnen worden gebruikt als formele parameters van subroutine-aanroepen in plaats van het basistype. Als er bijvoorbeeld een procedure wordt gedeclareerd

functie MylntFunc (APar: geheel getal): geheel getal;

dan zo'n beroep op haar

MylntFunc (MylntVar)

zal door de compiler als onjuist worden beschouwd.

Sterk getypte aliassen zorgen ervoor dat de compiler runtime type-informatie (RTTI) genereert. Deze informatie wordt meestal door de Delphi-omgeving gebruikt om het functioneren van verschillende soorten editors te ondersteunen.

Elk programma dat in elke programmeertaal is geschreven, is over het algemeen bedoeld voor gegevensverwerking. De gegevens kunnen getallen, teksten, afbeeldingen, geluid, enz. zijn. Sommige gegevens zijn initieel, andere - het resultaat, dat wordt verkregen door de initiële gegevens door het programma te verwerken.

De gegevens worden opgeslagen in het geheugen van de computer. Het programma verwijst ernaar met behulp van variabelenamen die zijn gekoppeld aan de geheugenlocaties waar de gegevens zijn opgeslagen.

Variabelen worden beschreven vóór de hoofdprogrammacode. De namen van de variabelen en het type gegevens dat erin is opgeslagen, worden hier gespecificeerd.

Er zijn veel gegevenstypen in de programmeertaal Pascal. Daarnaast kan de gebruiker zelf zijn eigen typen definiëren.

Het type variabele bepaalt welke gegevens kunnen worden opgeslagen in de bijbehorende geheugenlocatie.

Variabelen van het type geheel getal kan alleen worden geassocieerd met integer-waarden, meestal in het bereik van -32768 tot 32767. Pascal heeft andere integer-typen (byte, longint).

Variabelen van het type echt echte (fractionele) getallen opslaan.

Variabele booleaans(booleaans) type kan maar twee waarden aannemen - waar(1, waar) of vals(0, vals).

Karaktertype (char) kan waarden aannemen uit een specifieke geordende reeks tekens.

Intervaltype: door de gebruiker gedefinieerd en alleen gegenereerd op basis van ordinale typen. Vertegenwoordigt een subset van waarden in een specifiek bereik.

U kunt uw eigen gegevenstype maken door simpelweg de waarden op te sommen die een variabele van dat type kan aannemen. Dit is de zogenaamde opgesomd gegevenstype.

Al het bovenstaande zijn eenvoudige gegevenstypen. Maar er zijn ook complexe, gestructureerde, die gebaseerd zijn op eenvoudige typen.

Array Is een structuur die een enkel gebied in het geheugen inneemt en bestaat uit een vast aantal componenten van hetzelfde type.

Snaren is een opeenvolging van karakters. Bovendien mag het aantal van deze karakters niet meer dan 255 zijn, inclusief. Deze beperking is kenmerkend voor Pascal.

Opnemen Is een structuur die bestaat uit een vast aantal componenten die velden worden genoemd. Gegevens in verschillende velden van een record kunnen van een ander type zijn.

de sets zijn een verzameling van een willekeurig aantal elementen, maar van hetzelfde type opsomming.

Bestanden voor Pascal zijn reeksen van hetzelfde type gegevens die zijn opgeslagen op externe geheugenapparaten (bijvoorbeeld een harde schijf).

Het concept van een gegevenstype zoals wijzer geassocieerd met de dynamische opslag van gegevens in het computergeheugen. Vaak is het gebruik van dynamische gegevenstypen efficiënter bij het programmeren dan statische.

De les bespreekt de belangrijkste standaard datatypes in Pascal, het concept van een variabele en een constante; legt uit hoe u met rekenkundige bewerkingen werkt

Pascal is een getypte programmeertaal. Dit betekent dat de variabelen die de gegevens opslaan van een specifiek gegevenstype zijn. Die. het programma moet direct aangeven welke gegevens in een bepaalde variabele kunnen worden opgeslagen: tekstgegevens, numerieke gegevens, indien numeriek, dan integer of fractioneel, enz. Dit is in de eerste plaats nodig zodat de computer "weet" welke bewerkingen met deze variabelen kunnen worden uitgevoerd en hoe deze correct moeten worden uitgevoerd.

Bijvoorbeeld, de toevoeging van tekstuele gegevens, of zoals het correct wordt genoemd in het programmeren - aaneenschakeling is de gebruikelijke aaneenschakeling van strings, terwijl de toevoeging van numerieke gegevens bitsgewijze plaatsvindt, daarnaast worden fractionele en gehele getallen ook op verschillende manieren toegevoegd. Hetzelfde geldt voor andere operaties.

Laten we eens kijken naar de meest voorkomende gegevenstypen in Pascal.

Integer gegevenstypen naar Pascal

Houd er rekening mee dat bij het schrijven van programma's in pascal geheel getal(vertaald uit het Engels. integer) wordt het meest gebruikt, omdat het waardenbereik het meest gevraagd is. Als een groter bereik nodig is, gebruik dan verlangen naar(long integer, vertaald uit het Engels.Long integer). Een type byte in Pascal wordt het gebruikt wanneer het niet nodig is om met negatieve waarden te werken, hetzelfde geldt voor het type woord(alleen het bereik van waarden is hier veel groter).

Voorbeelden van hoe variabelen worden beschreven (gedeclareerd) in Pascal:

programma a1; var x, y: geheel getal; (geheel getal) mijnnaam: string; (stringtype) begin x: = 1; y: = x + 16; mijnnaam: = "Peter"; writeln ("naam:", mijnnaam, ", leeftijd:", y) end.

Resultaat:
naam: Peter, leeftijd: 17

Opmerkingen in Pascal

Merk op hoe gebruikt opmerkingen in Pascal... In het voorbeeld zijn de opmerkingen, d.w.z. servicetekst die "onzichtbaar" is voor de compiler, staan ​​tussen accolades. Meestal worden opmerkingen gemaakt door programmeurs om codefragmenten uit te leggen.

Doelstelling 3. De bevolking van Moskou is a = 9.000.000 inwoners. De bevolking van New Vasyuki is b = 1000 inwoners. Schrijf een programma dat het verschil in aantal inwoners tussen twee steden bepaalt. Variabelen gebruiken

Echte gegevenstypen in Pascal

Reële getallen in Pascal en in het algemeen in programmeren zijn de naam van fractionele getallen.

Het echte type in Pascal is het meest gebruikte type echt.

Hierboven werden gepresenteerd eenvoudige gegevenstypen in Pascal, waaronder:

• ordinaal
• Geheel
• denkspelletje
• Karakter
• opgesomd
• Interval
• Echt

Om de waarden van variabelen van een reëel type weer te geven, wordt meestal geformatteerde uitvoer gebruikt:

in het formaat wordt ofwel één nummer gebruikt, waarmee het aantal posities wordt aangegeven dat aan dit nummer is toegewezen in exponentiële vorm;

p: = 1234,6789; Schrijven (p: 6: 2); (1234.68)

Naast eenvoudige typen gebruikt de taal ook gestructureerde gegevenstypen en verwijzingen, die zal worden gewijd aan de volgende lessen in Pascal.

Constanten in Pascal

Vaak weet een programma van tevoren dat een variabele een bepaalde waarde zal aannemen en zal deze gedurende de uitvoering van het gehele programma niet veranderen. In dit geval moet u een constante gebruiken.

De declaratie van een constante in Pascal vindt plaats vóór de declaratie van variabelen (vóór het functiewoord var) en ziet er als volgt uit:

Een voorbeeld van het beschrijven van een constante in Pascal:

const x = 17; var mijnnaam: tekenreeks; begin mijnnaam: = "Peter"; writeln ("naam:", mijnnaam, ", leeftijd:", x) end.

"Mooie" weergave van gehele getallen en reële getallen

Om na het weergeven van de waarden van variabelen inspringingen te laten, zodat de waarden niet met elkaar "samenvloeien", is het gebruikelijk om via een dubbele punt aan te geven hoeveel tekens er moeten worden opgegeven voor het weergeven van de waarde:

Rekenkundige bewerkingen in Pascal

De volgorde van bewerkingen

1. evaluatie van uitdrukkingen tussen haakjes;
2. vermenigvuldigen, delen, div, mod van links naar rechts;
3. optellen en aftrekken van links naar rechts.

Pascal standaard rekenkundige procedures en functies

Hier is het de moeite waard om dieper in te gaan op enkele rekenkundige bewerkingen.

• De Pascal inc-bewerking, uitgesproken increment, is de standaard pascal-procedure, wat increment met één betekent.

Een voorbeeld van een inc-operatie:

x: = 1; inclusief (x); (Verhoogt x met 1, d.w.z. x = 2) writeln (x)

Complexer gebruik van inc-procedure:
Inc (x, n) waarbij x - ordinaal type, n - integer type; inc procedure verhoogt x met n.

• De Dec-procedure in Pascal werkt op een vergelijkbare manier: Dec (x) - verlaagt x met 1 (verlaging) of Dec (x, n) - verlaagt x met n.
• De abs-operator is de modulus van een getal. Het werkt als volgt:

een: = - 9; b: = buikspieren (a); (b = 9)

een: = - 9; b: = buikspieren (a); (b = 9)

• De div-operator in pascal is een veelgebruikte omdat er een aantal taken zijn bij het delen van gehele getallen.
• De rest van de deling of de operator mod in pascal is ook onmisbaar voor het oplossen van een aantal problemen.
• Opmerkelijk is de standaard oneven functie van Pascal, die bepaalt of een geheel getal oneven is. Dat wil zeggen, het retourneert waar voor oneven getallen, onwaar voor even getallen.

Een voorbeeld van het gebruik van de oneven functie:

var x: geheel getal; begin x: = 3; schrijven (sqr (x)); (antwoord 9) einde.

• Machtsverheffen in Pascal als zodanig afwezig. Maar om een ​​getal tot een macht te verhogen, kun je de exp-functie gebruiken.

De formule is als volgt: exp (ln (a) * n), waarbij a een getal is, n een graad (a> 0).

In de pascal abc-compiler is machtsverheffing echter veel eenvoudiger:

var x: geheel getal; begin x: = 9; schrijven (sqrt (x)); (antwoord 3) einde.

Taak 4. De afmetingen van de luciferdoos zijn bekend: hoogte - 12,41 cm, breedte - 8 cm, dikte - 5 cm.Bereken het gebied van de basis van de doos en het volume
(S = breedte * dikte, V = oppervlakte * hoogte)

Opdracht 5. De dierentuin heeft drie olifanten en nogal wat konijnen, waarbij het aantal konijnen regelmatig verandert. Een olifant hoort honderd wortelen per dag te eten en een konijn twee. Elke ochtend vertelt de verzorger van de dierentuin aan de computer het aantal konijnen. De computer moet in reactie daarop de minister het totale aantal wortelen vertellen dat vandaag aan konijnen en olifanten moet worden gevoerd.

Taak 6. Het is bekend dat x kg snoep is de moeite waard een roebels. Bepaal hoeveel het kost ja kg van deze snoepjes, en hoeveel kilo snoep je kunt kopen bij k roebels. Alle waarden worden door de gebruiker ingevuld.