Pascal-gegevenstypen
Alle gegevens (constanten, variabelen, functiewaarden of uitdrukkingen) in Turbo Pascal worden gekenmerkt door hun typen. Een type definieert de set geldige waarden die een object kan hebben, evenals de set geldige bewerkingen die erop kan worden toegepast. Het type bepaalt ook het formaat van de interne weergave van gegevens in het computergeheugen.
De volgende gegevenstypen bestaan in Turbo Pascal.
1) Eenvoudige soorten:
- echt;
- symbolisch;
- booleaans (logisch);
- vermeld;
- beperkt bereik).
2) Samengestelde (gestructureerde) types:
– regulier (arrays);
– gecombineerd (records);
- het dossier;
- meerdere;
- snaar;
- voorwerpen.
3) Referentietypes (getypte en niet-getypte pointers).
4) Procedurele typen.
Turbo Pascal biedt een mechanisme voor het maken van nieuwe gegevenstypen, zodat het totale aantal typen dat in het programma wordt gebruikt, willekeurig groot kan zijn.
integer type. Integer type waarden zijn elementen van een subset van gehele getallen. Er zijn vijf integer-typen in Turbo Pascal. Hun namen, waardenbereik, lengte van representatie in bytes worden gegeven in de tabel. 6.
Tabel 6
Gegevenstypen voor geheel getal
Integer-variabelen worden gedeclareerd met de bovenstaande gereserveerde woorden:
i, j, k: geheel getal;
Gegevens van het gehele type worden exact in het geheugen opgeslagen. Variabelen van het type integer nemen bijvoorbeeld 2 bytes (16 bits) in het geheugen in beslag, die als volgt zijn verdeeld: 1 bit is gereserveerd voor het opslaan van het teken van het getal (0 als het getal positief is en 1 als het getal negatief is) en 15 bits voor het opslaan van het getal in binaire systeemberekening. Het maximale decimale getal dat als 15-bits binair kan worden geschreven, is 32767.
Bij het gebruik van procedures en functies met integer-parameters moet men zich laten leiden door het "nesten" van typen, d.w.z. overal waar woord wordt gebruikt, is byte toegestaan (maar niet omgekeerd), longint "inclusief" integer, dat op zijn beurt shortint bevat.
Het integer type definieert vijf basisbewerkingen die ook resulteren in een integer: +, -,*, div, mod (optellen, aftrekken, vermenigvuldigen, integer delen en integer delen rest). In rekenkundige uitdrukkingen hebben de bewerkingen *, div, mod een hogere prioriteit dan de bewerkingen +, -. Voorbeelden van schrijfuitdrukkingen:
De lijst met procedures en functies die van toepassing zijn op typen integers wordt gegeven in Tabel. 7. De letters b, s, w, i, l geven uitdrukkingen aan van respectievelijk het type byte, shortint, word, integer en longint; x is een uitdrukking van elk van deze typen; identifiers vb, vs, vw, vi, vl, vx duiden variabelen van de overeenkomstige typen aan. Een optionele parameter wordt tussen vierkante haken aangegeven.
Tabel 7
Standaardprocedures en -functies die van toepassing zijn op gehele typen
| Hoger beroep | Type resultaat | Actie |
| buikspieren(x) | x | Retourmodule x |
| Chr(b) | Char | Retourneert een teken door zijn code |
| Dec(vx[,i]) | - | Verlaagt de waarde van vx met i, en bij afwezigheid van i - met 1 |
| Inc(vx[,i]) | - | Verhoogt de waarde van vx met i, en bij afwezigheid van i - met 1 |
| Hallo (ik) | bytes | Retourneert de hoge byte van het argument |
| Hallo (ik) | bytes | Dezelfde |
| Lo(i) | bytes | Retourneert de lage byte van het argument |
| laag) | bytes | Dezelfde |
| Oneven(l) | bytes | Retourneert waar als het argument een oneven getal is |
| Willekeurig(w) | Als parameter: | Retourneert een pseudo-willekeurig getal uniform verdeeld in het bereik 0...(w-1) |
| Vierkant(x) | x | Geeft het kwadraat van het argument |
| Ruil(ik) | Geheel getal | |
| Ruil (w) | Woord | Wissel bytes in een woord |
| Succ(x) | Als parameter: | Retourneert de volgende gehele waarde, d.w.z. x+1 |
| pred(x) | Als parameter: | Retourneert de vorige gehele waarde, d.w.z. x-1 |
Als u met gehele getallen werkt, komt het type resultaat overeen met het type operand, en als de operanden van verschillende typen gehele getallen zijn, met het type operand met het maximale waardenbereik. Eventuele overloop van het resultaat wordt niet gecontroleerd, wat kan leiden tot fouten in het programma.
Echte soort. Waarden van reële typen definiëren een willekeurig getal met enige eindige precisie, afhankelijk van het interne formaat van het reële getal. Er zijn vijf echte typen in Turbo Pascal (tabel 8).
Tabel 8
Echte gegevenstypen
Reële variabelen worden gedeclareerd met de bovenstaande gereserveerde woorden:
Een reëel getal in het computergeheugen bestaat uit 3 delen:
Het tekencijfer van het nummer;
Exponentieel deel;
De mantisse van het getal.
De mantisse heeft een lengte van 23 (enkel) tot 63 (uitgebreid) binaire cijfers, wat een nauwkeurigheid oplevert van 7-8 voor enkelvoudige en 19-20 voor uitgebreide decimale cijfers. De decimale punt (komma) wordt geïmpliceerd vóór het linker (meest significante) cijfer van de mantisse, maar wanneer met een getal wordt gewerkt, 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-komma-rekenkunde genoemd.
De typen Enkel, Dubbel en Uitgebreid zijn alleen toegankelijk in speciale compilatiemodi. Om deze modi in te schakelen, selecteert u het menu-item Opties, Compiler... en schakel de optie in 8087/80287 in een groep Numerieke verwerking.
Een speciale positie in Turbo Pascal wordt ingenomen door het Comp-type, dat wordt behandeld als een reëel getal zonder exponentiële en fractionele delen. In feite is Comp een groot geheel getal met teken dat 19 tot 20 significante decimale cijfers opslaat. Tegelijkertijd is Comp volledig compatibel met alle andere reële typen in uitdrukkingen: alle reële bewerkingen zijn erop gedefinieerd, het kan worden gebruikt als argument voor wiskundige bewerkingen, enz.
Reële getallen worden gegeven in decimale notatie in een van twee vormen.
IN vast punt vorm het record bestaat uit een geheel getal en een breuk, van elkaar gescheiden door een punt, bijvoorbeeld:
0.087 4.0 23.5 0.6
IN drijvende-kommavorm het item bevat de letter E, wat betekent "vermenigvuldigen met tien tot de macht", en de graad is een geheel getal, bijvoorbeeld:
7E3 6.9E-8 0.98E-02 45E+04
De volgende bewerkingen zijn gedefinieerd op objecten van het reële type: +, -, *, /.
De operators "*" en "/" hebben een hogere prioriteit dan de operators "+" en "-".
Als ten minste één operand reëel is, leiden de bewerkingen +, -, *, / tot een reëel resultaat. De delingsbewerking / leidt tot een reëel resultaat in het geval van twee gehele operanden, bijvoorbeeld: 9/3 = 3,0.
Om met echte gegevens te werken, kunnen de standaard wiskundige functies in tabel 1 worden gebruikt. 9. Het resultaat van deze functies is ook reëel.
Tabel 9
Wiskundige functies die werken met echte gegevens
Variabelen en constanten van het type REAL mogen niet worden gebruikt:
– in de functies pred(x), succ(x), ord(x);
– als indexen van arrays;
– als labels in controleoverdrachtverklaringen;
– als controlevariabelen (cyclusparameters).
Om een reëel getal naar een geheel getal om te zetten, kunt u de volgende functies gebruiken:
trunc(x) is het gehele deel van x (x is reëel);
round(x) – afronding naar het dichtstbijzijnde gehele getal (x is reëel).
karakter soort. Karaktervariabelen worden gedeclareerd met het gereserveerde woord char:
Waarden van dit type worden geselecteerd uit een geordende set tekens (uit de ASCII-set) bestaande uit 256 tekens. Aan elk teken wordt een geheel getal toegewezen uit het bereik 0..255. Hoofdletters van het Latijnse alfabet A..Z hebben bijvoorbeeld de codes 65..90 en kleine letters hebben de codes 97..122.
De waarde van een tekentypevariabele is een enkel teken tussen apostrofs, bijvoorbeeld:
'F' '8' '*'
Tekenvariabelen kunnen met elkaar worden vergeleken door tekencodes te vergelijken.
Er zijn functies die een overeenkomst tot stand brengen tussen een teken en zijn code:
ord(с) - geeft het nummer van het symbool van;
chr(i) - geeft het teken met nummer i terug.
Deze functies zijn omgekeerd van elkaar.
booleaans type. Booleaanse variabelen worden gedeclareerd met het gereserveerde woord boolean:
p1, p2: booleaans;
Booleaanse variabelen hebben twee waarden: waar(waar), vals(Fout).
Deze waarden zijn als volgt geordend: false< true. false имеет порядковый номер 0, true имеет порядковый номер 1.
Booleaanse variabelen kunnen ofwel direct een waarde toegewezen krijgen, of er kan een booleaanse uitdrukking worden gebruikt. Bijvoorbeeld,
a, d, g, b: booleaans;
relationele operaties (<, <=, >, >=, =, <>) toegepast op integer-, real- en character-variabelen produceren een booleaans resultaat.
Logische bewerkingen op operanden van een booleaans type geven ook een logisch resultaat (de bewerkingen worden weergegeven in aflopende volgorde van prioriteit) (voor details, zie tabellen 3 en 5):
niet – ontkenning (NIET bewerking);
en - logische vermenigvuldiging (operatie AND);
of – logische toevoeging (OF-bewerking);
xor - exclusief OR.
De uitdrukking (niet a) heeft de tegenovergestelde betekenis van a.
De uitdrukking (a en b) evalueert alleen waar als zowel a als b waar zijn, anders is de waarde van deze uitdrukking onwaar.
De uitdrukking (a of b) evalueert alleen onwaar als zowel a als b onwaar zijn, in alle andere gevallen is het resultaat waar.
opgesomd type. Een niet-standaard opgesomd type wordt door de opsomming gespecificeerd als de namen van de waarden die de variabele kan aannemen. Elke waarde wordt genoemd door een identificatie en bevindt zich in een lijst tussen haakjes. De algemene vorm van de opgesomde typebeschrijving:
x = (w1, w2, …, wn);
waarbij x de naam is van het type, w1, w2,…, wn de waarden zijn die een variabele van het type x kan aannemen.
Deze waarden zijn besteld w1 De volgende standaardfuncties zijn van toepassing op een opgesomd typeargument w: succ(w), pred(w), ord(w). kleur=(rood, zwart, geel, groen) ww=(links, omhoog, rechts, omlaag); f: array van ww; succ(d) = geel; Variabelen a en b zijn van het type w. ze kunnen een van de drie waarden aannemen, en verder Relationele bewerkingen zijn van toepassing op waarden van het opgesomde type: =,<>, <=, >=, <, >. Het is toegestaan om opgesomde typeconstanten rechtstreeks in de sectie op te geven var zonder sectie te gebruiken type, bijvoorbeeld c,d: (rood, zwart, geel, groen); Bereik (beperkt) type. Wanneer u een begrensd type definieert, geeft u de begin- en eindwaarden op die een variabele van het bereiktype kan aannemen. De waarden worden gescheiden door twee punten. De beschrijving van een beperkt type is: Hier is a de naam van het type, min, max zijn constanten. Bij het specificeren van een beperkt type moeten de volgende regels worden gevolgd: – beide grensconstanten min en max moeten van hetzelfde type zijn; – Er wordt een beperkt type gemaakt op basis van de gegevens van het basistype, dat een geheel getal, teken of opgesomd type kan zijn. Bijvoorbeeld: kleur = rood..geel; letter = 'a'..'f'; - Variabelen van een beperkt type kunnen worden gedeclareerd in de var-sectie zonder te verwijzen naar de typesectie: – een beperkt type erft alle eigenschappen van het basistype waaruit het is gemaakt; – de min-limiet moet altijd lager zijn dan de max-limiet. arrays. Een array is een complex type, een structuur die bestaat uit een vast aantal componenten van hetzelfde type. Het type van de component wordt het basistype genoemd. Alle arraycomponenten kunnen eenvoudig worden besteld en elk ervan is toegankelijk door eenvoudig het volgnummer op te geven. Beschrijving van de array in de sectie var lijkt op: een: reeks van t2; waarbij a de naam van de array is, reeks, van– servicewoorden (betekent "reeks van ..."), t1 - indextype; t2 – componenttype (basistype). Het aantal indexen bepaalt de afmeting van de array. Indexen kunnen van het type integer (behalve longint), karakter, boolean, enumerated en range zijn. Indexen worden gescheiden door komma's en tussen vierkante haken geplaatst. Matrixcomponenten kunnen van elk type zijn, behalve bestand. voorbeeld 1 Overweeg een eendimensionale array C, waarvan de waarden vijf reële getallen zijn: 4.6 6.23 12 -4.8 0.7 De beschrijving van deze array is als volgt: c: array van echt; Met een specifieke indexwaarde kunt u een specifieke arraycomponent selecteren (bijvoorbeeld C betekent het derde element van array C, d.w.z. het getal 12). Voorbeeld 2 Beschouw een tweedimensionale array B (matrix B) waarvan de waarde een tabel met gehele getallen is: De beschrijving van deze array is als volgt: b van geheel getal; Hier is b de naam van de array, de eerste index is het rijnummer en heeft waarden van 1 tot 2, de tweede is het kolomnummer en heeft waarden van 1 tot 4. Door specifieke indexwaarden kunt u selecteren een specifieke arraycomponent (b betekent bijvoorbeeld een tabelelement in de eerste rij en derde kolom, d.w.z. het getal -4). Indexen kunnen willekeurige uitdrukkingen zijn, overeenkomend met het type indexen uit de array-declaratie: a: array van echt; a[(i+1)*2] := 24; De reeks bewerkingen op array-elementen wordt volledig bepaald door het type van deze elementen. snaartype. Tekenreekstype - een reeks tekenreeksen van willekeurige lengte (van nul tot een bepaald aantal). Variabelen van het stringtype worden beschreven met een servicewoord snaar: B: snaar ; Eigenaardigheden: – de waarde van een stringvariabele kan worden ingevoerd met behulp van het toetsenbord, toegewezen in een toewijzingsinstructie, gelezen uit een bestand. In dit geval kan de lengte van de ingevoerde string willekeurig zijn (kleiner dan de gespecificeerde grootte, gelijk aan de grootte of meer, in het laatste geval worden extra tekens weggegooid); a:= 'Resultaten'; – het is toegestaan om de aaneenschakeling te gebruiken in de toewijzingsoperator, aangezien strings dynamisch hun lengte kunnen veranderen: a:= a + ‘berekeningen’; – de maximale lengte van een stringvariabele is 255 karakters, deze lengte-aanduiding kan weggelaten worden: een: snaar; a1: snaar ; Variabelen a en a1 zijn hetzelfde (equivalente beschrijving). - geheugen voor stringtypevariabelen wordt maximaal toegewezen, maar slechts een deel van het geheugen dat op dat moment daadwerkelijk wordt ingenomen door de karakters van de string wordt gebruikt. Om een stringvariabele met lengte n te beschrijven, worden n + 1 bytes geheugen gebruikt: n bytes - om de karakters van de string op te slaan, n + 1 -de byte - om de huidige lengte op te slaan. – vergelijkingsbewerkingen worden gedefinieerd op waarden van stringtypes:< <= > >= = <>. Een korte string is altijd minder dan een lange. Als de strings even lang zijn, worden de tekencodes vergeleken. – toegang tot individuele elementen van een string is mogelijk op dezelfde manier als toegang tot array-elementen: a, a. Vierkante haken geven het nummer van het element van de lijn aan. Procedures en functies gericht op het werken met strings. concat (s1, s2,...)- string samenvoegfunctie, s1, s2,…- regels, het aantal regels kan willekeurig zijn. Het resultaat van de functie is een string. Als de resulterende tekenreeks langer is dan 255 tekens, wordt de tekenreeks afgekapt tot 255 tekens. kopie(ën, index, telling)– functie van het extraheren van een string uit de bronstring s lang Graaf tekens beginnend met tekennummer inhoudsopgave. verwijderen(en, index, tellen) is de procedure voor het verwijderen van de string s een substring van lengte Graaf tekens, beginnend met een teken met een cijfer inhoudsopgave. invoegen (s1, s2, index)- procedure voor het invoegen van regels s1 in een string s2, beginnend met een teken met een cijfer inhoudsopgave. lengte(s)– functie voor het bepalen van de huidige lengte van de string, geeft een getal terug dat gelijk is aan de huidige lengte van de string. pos(s1, s2)- zoekfunctie in een string s2 substrings s1. geeft het positienummer van het eerste teken van een subtekenreeks terug s1 in lijn s2(of 0 als deze regel niet bestaat). val(st, x, code)– procedure voor het converteren van de string s naar een geheel getal of reële variabele x. Parameter code bevat 0 als de conversie is gelukt (en in x het resultaat van de conversie wordt geplaatst), of het positienummer van de tekenreeks waar het foutieve teken is gevonden (in dit geval de waarde x verandert niet). Compatibiliteit en typeconversie. Turbo Pascal is een getypte taal. Het is gebouwd op basis van strikte naleving van het concept van typen, volgens welke alle bewerkingen die in de taal worden gebruikt, alleen worden gedefinieerd op operanden van compatibele typen. Twee typen worden als compatibel beschouwd als: - ze zijn beide van hetzelfde type; zijn beide echt; - beide zijn intact – één type is een bereiktype van het tweede type; – beide zijn bereiktypen van hetzelfde onderliggende type; – beide sets zijn samengesteld uit elementen van hetzelfde basistype; – beide zijn verpakte strings (gedefinieerd met een voorafgaand verpakt woord) van dezelfde maximale lengte; - de ene is een typestring en de andere is een typestring of teken; - het ene type is een willekeurige aanwijzer en het andere is een aanwijzer naar een gerelateerd object; – beide zijn procedurele typen met hetzelfde resultaattype (voor een functietype), het aantal parameters en het type onderling corresponderende parameters. Typecompatibiliteit krijgt een speciale betekenis in toewijzingsinstructies. Laat t1 het type van de variabele zijn en t2 het type van de uitdrukking, dat wil zeggen, de toewijzing is t1:=t2. Deze toewijzing is mogelijk in de volgende gevallen: – t1 en t2 zijn van hetzelfde type, en dit type is niet van toepassing op bestanden, arrays van bestanden, records die bestandsvelden bevatten of arrays van dergelijke records; – t1 en t2 zijn compatibele ordinale typen en de waarde van t2 ligt in het bereik van mogelijke waarden van t1; – t1 en t2 zijn reële typen, en de waarde van t2 ligt in het bereik van mogelijke waarden van t1; – t1 is een reëel type en t2 is een geheel getal; – t1 – tekenreeks en t2 – symbool; – t1 is een string en t2 is een ingepakte string; – t1 en t2 zijn compatibele verpakte strings; – t1 en t2 zijn compatibele sets en alle leden van t2 behoren tot de set van mogelijke waarden van t1; – t1 en t2 zijn compatibele wijzers; – t1 en t2 zijn compatibele procedurele typen; – t1 is een object en t2 is zijn kind. In een programma kunnen gegevens van het ene type worden geconverteerd naar gegevens van een ander type. Een dergelijke omzetting kan expliciet of impliciet zijn. Expliciete typeconversie roept speciale conversiefuncties aan waarvan de argumenten van het ene type zijn en waarvan de waarden van een ander type zijn. Een voorbeeld is de reeds overwogen functies ord, trunc, round, chr. Impliciete conversie is alleen mogelijk in twee gevallen: - in uitdrukkingen die bestaan uit reële en gehele variabelen, worden deze laatste automatisch geconverteerd naar een reëel type, en krijgt de hele uitdrukking als geheel een reëel type; - hetzelfde geheugengebied wordt afwisselend behandeld als gegevens van een of ander type (combinatie van gegevens van verschillende typen in het geheugen). 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 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. Het toevoegen van tekstgegevens, of zoals het correct wordt genoemd in het programmeren - aaneenschakeling - is bijvoorbeeld de gebruikelijke samenvoeging van strings, terwijl het toevoegen van numerieke gegevens bit voor bit plaatsvindt, daarnaast worden fractionele en gehele getallen ook in verschillende manieren. Hetzelfde geldt voor andere operaties. Overweeg de meest voorkomende gegevenstypen in Pascal. Houd er rekening mee dat bij het schrijven van programma's in Pascal geheel getal(vertaald uit het Engels als een geheel getal) 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). 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; varx,y:geheel getal; (geheel getal) mijnnaam:string; (stringtype) begin x:=1; y:=x+16; mijnnaam:="Peter"; writeln ("naam: ", mijnnaam", ", leeftijd: ", y) end. Resultaat: Let op hoe Pascal-opmerkingen worden gebruikt. In het voorbeeld zijn opmerkingen, d.w.z. servicetekst die voor de compiler "niet zichtbaar" is, staat tussen accolades. Meestal worden opmerkingen gemaakt door programmeurs om codefragmenten te verduidelijken. Taak 3. De bevolking van Moskou is a = 9.000.000 inwoners. De bevolking van New Vasyukov is gelijk aan b=1000 inwoners. Schrijf een programma dat het verschil in aantal inwoners tussen twee steden bepaalt. Variabelen gebruiken Reële getallen in Pascal en in het algemeen in programmeren is de naam van fractionele getallen. Het echte type in Pascal is het meest gebruikte type echt. Hierboven werden gepresenteerd eenvoudige gegevenstypen in Pascal, waaronder: Om de waarden van variabelen van een reëel type uit te voeren, wordt meestal geformatteerde uitvoer gebruikt: p:=1234.6789; WriteIn(p:6:2); (1234.68) Naast eenvoudige typen gebruikt de taal ook gestructureerde gegevenstypen en verwijzingen, die het onderwerp zullen zijn van de volgende Pascal-lessen. Vaak is het in het programma van tevoren bekend dat de variabele een bepaalde waarde zal aannemen en niet veranderen tijdens de uitvoering van het hele programma. 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 servicewoord var) en ziet er als volgt uit: Een voorbeeld van een constante beschrijving in Pascal: const x=17; varmynaam:string; begin mijnnaam:="Peter"; writeln ("naam: ", mijnnaam", ", leeftijd: ", x) end. Om na de uitvoer van de waarden van de variabelen streepjes te laten, zodat de waarden niet met elkaar "samenvloeien", is het gebruikelijk om via een dubbele punt aan te geven hoeveel karakters er voor de uitvoer moeten worden opgegeven van de waarde: Hier is het de moeite waard om dieper in te gaan op enkele rekenkundige bewerkingen. Inc operatie voorbeeld: x:=1; inclusief(x); (Verhoogt x met 1, d.w.z. x=2) writeln (x) Een complexer gebruik van de inc-procedure: een:=-9; b:=abs(a); (b=9) Een voorbeeld van het gebruik van de oneven functie: varx:geheel getal; beginx:=3; writeln(sqr(x)); (antwoord 9) einde. De formule is: exp(ln(a)*n) , waarbij a een getal is, n een macht (a>0). In de pascal abc-compiler is machtsverheffing echter veel eenvoudiger: varx:geheel getal; beginx:=9; writeln(sqrt(x)); (antwoord 3) einde. Taak 4. De afmetingen van een luciferdoosje zijn bekend: hoogte - 12,41 cm, breedte - 8 cm, dikte - 5 cm Bereken het basisoppervlak van de doos en het volume Opdracht 5. Er zijn drie olifanten en nogal wat konijnen in de dierentuin, en het aantal konijnen verandert regelmatig. Een olifant hoort honderd wortelen per dag te eten en een konijn twee. Elke ochtend meldt de dierenverzorger het aantal konijnen aan de computer. De computer moet als reactie de bediende het totale aantal wortelen vertellen dat vandaag aan konijnen en olifanten moet worden gevoerd. Taak 6. Het is bekend dat x kg snoep een roebels. Bepaal hoeveel ja kg van deze snoepjes, en op hoeveel kilo snoepjes kan worden gekocht k roebels. Alle waarden worden door de gebruiker ingevuld. Om ervoor te zorgen dat de machine elke invoer kan verwerken, moet deze "begrijpen" tot welk type de variabelen behoren waarin de waarden worden ingevoerd. Bij gebrek aan informatie over het gegevensformaat kan de computer niet bepalen of deze of gene bewerking in een bepaald geval is toegestaan: het is bijvoorbeeld intuïtief duidelijk dat je een letter niet tot een macht kunt verheffen of de integraal kunt nemen van een touwtje. De gebruiker moet dus bepalen welke acties met elke variabele mogen worden uitgevoerd. Net als in andere programmeertalen op hoog niveau, zijn variabele typen in Pascal geoptimaliseerd om taken van verschillende richtingen uit te voeren, hebben ze een ander waardenbereik en lengte in bytes. Soorten variabelen in Pascal zijn onderverdeeld in eenvoudig en gestructureerd. Eenvoudige typen omvatten reële en ordinale typen. Gestructureerde omvatten arrays, records, sets en bestanden. Afzonderlijk toegewezen wijzers, objecten en procedurele typen. Overweeg ordinale en reële typen. Ordinale typen omvatten 5 integer-typen, een opgesomd type en een bereiktype. Er zijn 5 typen integers, die verschillen in lengte in bytes en waardenbereik. De lengte van Byte en ShortInt is 1 byte. Het verschil tussen beide is dat Byte alleen niet-negatieve waarden opslaat, terwijl ShortInt u in staat stelt negatieve waarden op te slaan (van -128 tot +127). De typen Word en Integer zijn op dezelfde manier aan elkaar gerelateerd, met als enige verschil dat hun grootte 2 bytes is. Ten slotte kunt u met LongInt zowel negatieve als positieve waarden opslaan met 4 bytes - in de numerieke dimensie van de 16e macht aan weerszijden van nul. Verschillende soorten variabelen in Pascal dragen bij aan de effectieve oplossing van gebruikerstaken, omdat in elk specifiek geval zowel een klein als een groot bereik aan waarden nodig kan zijn, en er kunnen ook beperkingen zijn aan de hoeveelheid toegewezen geheugen . Het is belangrijk om te begrijpen dat nul evenveel geheugenruimte in beslag neemt als elk ander getal. Dus bij het vormen van een reeks waarden, zal het minimale negatieve getal modulo één meer zijn dan een positief: bijvoorbeeld van -128 tot +127. Variabelen die bij horen kunnen TRUE (true) of FALSE (false) zijn en vereisen 1 byte geheugen. Met het CHAR-type kunt u elk van de vele tekens opslaan die in het computergeheugen aanwezig zijn. Tegelijkertijd wordt in symbolische variabelen in Pascal alleen de tekencode daadwerkelijk opgeslagen, in overeenstemming met de grafische vorm ervan. Onder de soorten variabelen in Pascal zijn er verschillende numerieke met de mogelijkheid om een fractioneel deel te schrijven. Het verschil tussen de typen Single, Real, Double en Extended komt neer op het bereik van geaccepteerde waarden, het aantal significante cijfers achter de komma en de grootte in bytes. In overeenstemming met de hierboven weergegeven volgorde, zal een variabele van elk type 4, 6, 8 of 10 bytes in beslag nemen. Gestructureerde datatypes zijn complex en stellen je in staat om een aantal simpele waarden te combineren binnen één variabele. Een treffend voorbeeld is een array, die als volgt kan worden gespecificeerd: String=array van char; We hebben dus een type met de naam String, waarmee je variabelen kunt instellen met een lengte van 100 tekens. De laatste regel specificeert direct een eendimensionale array Y van het type String. De beschrijving van variabelen in Pascal wordt uitgevoerd door de identifier aan de linkerkant te plaatsen, en de waarde van de variabele aan de rechterkant, na het gelijkteken. Met het indexbereik dat erin is geschreven, hebt u toegang tot elk specifiek element van de array: In dit geval lezen we het tweede element van de eerder gemaakte Y-array. Een speciaal geval van een eendimensionale array zijn ook stringvariabelen in Pascal, omdat een string een reeks karakters is, d.w.z. elementen van het char-type. Het record bestaat uit verschillende velden die zijn gevuld met gegevens van elk type behalve bestand. Over het algemeen is een variabele van dit type vergelijkbaar met een database-element. U kunt er bijvoorbeeld de naam en het telefoonnummer van een persoon in invoeren: type NTel = Record De eerste regel bevat links de typenaam en rechts het servicewoordrecord. De tweede regel bevat het veld met de naam, de derde - het telefoonnummer. Het woord "einde" geeft aan dat we alle velden hebben ingevoerd die we wilden, en dit voltooit het proces van het maken van een record. Ten slotte definiëren we op de laatste regel de variabele One, die van het type NTel is. U kunt zowel naar het record als geheel als naar de afzonderlijke componenten ervan verwijzen, bijvoorbeeld: one.NAME (d.w.z. variabele_naam.record_field_name). Pascal stelt u in staat om te werken met tekst, getypte en ongetypte bestanden, die een gestructureerde opeenvolging zijn van componenten van hetzelfde type. Bij het lezen van of schrijven naar een bestand kunnen zowel het volledige adres als de korte vorm worden gebruikt: 'C:\Folder\File2.txt' De korte vorm wordt gebruikt wanneer het bestand zich in de map bevindt waarin het programma dat toegang heeft tot het bestand is opgeslagen. Het volledige formulier kan onder alle omstandigheden worden gebruikt. U kunt een bestandstypevariabele als volgt instellen: f1: bestand van geheel getal; Om met bestanden te werken, worden verschillende functies en procedures gebruikt die een variabele koppelen aan een bestand op schijf, het openen voor lezen, schrijven en overschrijven, sluiten wanneer u klaar bent, zodat u een nieuwe naam kunt maken en het bestand van de computer kunt verwijderen . Zonder de mogelijkheid om verschillende soorten variabelen in Pascal te gebruiken, kan de gebruiker zelfs de eenvoudigste taak niet uitvoeren. Om ervoor te zorgen dat het programma het algoritme foutloos uitvoert, is het noodzakelijk om zowel de servicewoorden als de syntaxis te leren, aangezien de machine opdrachten alleen kan "begrijpen" als ze op de enige juiste manier zijn geschreven. Het concept van type is een van de fundamentele concepten van elke programmeertaal. Objecten (constanten, variabelen, functies, uitdrukkingen) waarop het programma werkt, zijn van een bepaald type. Type is de reeks waarden die programma-objecten kunnen aannemen, en de reeks bewerkingen die op deze waarden zijn toegestaan. Bijvoorbeeld, de waarden 1 en 2 zijn van het type integer, ze kunnen worden opgeteld, vermenigvuldigd en andere rekenkundige bewerkingen kunnen worden uitgevoerd. De betekenissen "monitor" en "Pascal" zijn taalkundig van aard, ze hebben hun eigen reeks geldige bewerkingen. In de meest gebruikte talen kunnen alleen goed gedefinieerde, bekende typen worden gebruikt. Pascal, samen met de standaardtypen die in andere talen op hoog niveau worden gevonden, stelt de programmeur in staat zijn eigen typen te maken. Alle soorten die in de Pascal-taal zijn toegestaan, zijn verdeeld in twee grote groepen: eenvoudig en complex (gestructureerd). Effectief gebruik van SINGLE, DOUBLE, EXTEND, COMP-types is alleen mogelijk als de richtlijn ($N+) is opgenomen. Standaard staat het in de uit-stand. Om technische en economische problemen op te lossen, zijn waarden van het REAL-type voldoende. Voorbeeld Var Res, Summa, Itog: echt; Bulevsky het datatype wordt beschreven door de identifier BOOLEAN. Variabelen en constanten van dit type kunnen slechts één van twee waarden aannemen: TRUE (true) of FALSE (false). Voorbeeld Var Sel1, Sel2: boolean; A,B,C,D: booleaans; Booleaanse expressies nemen 1 byte geheugen in beslag en worden gebruikt in logische en relationele expressies, evenals om de uitvoeringsvolgorde van programma-instructies te controleren. Letterlijk (karakter) het type wordt beschreven door de standaardidentificatie CHAR. Constanten en variabelen van dit type kunnen een van de waarden van de ASCII-codetabel aannemen. De waarde van een constante of variabele van dit type staat tussen apostrofs. Bijvoorbeeld, Var Bukva, Znak, Symbool: char; Letter:='A'; Teken:='+'; Symbool:='!' Variabelen van het type karakter nemen 1 byte in het geheugen in beslag. Het gebruik van gegevens van het type char in rekenkundige uitdrukkingen is verboden. Vergelijkingsbewerkingen kunnen worden toegepast op letterlijke waarden, waarvan het resultaat afhangt van het nummer van de letterlijke variabele of constante in de codetabel. Naast standaard datatypes ondersteunt Pascal scalaire types, gebruiker gedefinieerde. Waaronder opsombaar En interval types . Deze gegevenstypen nemen 1 byte geheugen in beslag, dus elk door de gebruiker gedefinieerd type kan niet meer dan 255 elementen bevatten. Het gebruik ervan verbetert de zichtbaarheid van het programma aanzienlijk, maakt het gemakkelijker om fouten te vinden en bespaart geheugen. opgesomd type wordt direct gespecificeerd door alle waarden op te sommen die een variabele van een bepaald type kan aannemen. Individuele waarden worden gescheiden door komma's en de hele lijst staat tussen haakjes. Formaat type<имя типа>=(<значение1, значение2, ..., значениеN>); Var<идентификатор, ...>: < имя типа>; Voorbeeld Type Seizoen =(Lente, Zomer, Herfst, Winter); Var S1, S2: Seizoen; Herfst: (september, oktober, nu); In dit voorbeeld wordt het expliciet gedeclareerde gegevenstype van de seizoengebruiker weergegeven. Hun betekenissen zijn bepaald - de aanduidingen van de seizoenen. Variabelen S1 en S2 kunnen slechts één van de vermelde waarden aannemen. Pogingen om er een andere waarde aan toe te kennen, zullen een software-onderbreking veroorzaken. Het derde type opsomming is anoniem (heeft geen naam) en wordt gespecificeerd door opsomming van waarden in de Var-sectie. De herfst is een variabele van dit type en kan de waarden September, Oktober, Nowember aannemen. Elk type kan dus worden gegeven, maar dit is niet altijd acceptabel. De eerste manier is zeker begrijpelijker en meer in lijn met de aard van de Pascal-taal. intervaltype: stelt u in staat om twee constanten in te stellen die de grenzen van het waardenbereik voor deze variabele definiëren. Telkens wanneer een bewerking wordt uitgevoerd op een variabele van het intervaltype, genereert de compiler controleroutines om te bepalen of de waarde van de variabele binnen het gespecificeerde bereik blijft. Beide constanten moeten tot een van de standaardtypen behoren, behalve real. De waarde van de eerste constante moet noodzakelijkerwijs kleiner zijn dan de waarde van de tweede. Formaat type<имя типа> = <константа1> .. <константа2>; Var<идентификатор>: < имя типа>; Voorbeeld Type Dagen = 1.. 31; Var Work_d, Free_d: Dagen; In dit voorbeeld zijn de variabelen Work_d, Free_d zijn van het type dagen en kan elke waarde uit het bereik 1 aannemen. . 31. Buiten bereik activeert een software-interrupt. U kunt een intervaltype definiëren door de bereiklimieten niet op te geven door constante waarden, maar door hun namen: Const Min = 1; maximaal=31; Type Dagen = Min .. Max; Var Work_d, Free_d: Dagen; Gestructureerde typen gegevens zijn gebaseerd op scalaire typen en kunnen verschillende combinaties daarvan bevatten. Ze definiëren een geordende reeks scalaire elementen en worden gekenmerkt door het type van hun componenten. Pascal biedt de volgende gestructureerde gegevenstypen: lijn - een reeks tekens tussen apostrofs; reeks - gestructureerd gegevenstype bestaande uit een vast aantal elementen van hetzelfde type, toegankelijk via index ;
veel - een set objecten geselecteerd volgens een attribuut of groep attributen, die als een geheel kan worden beschouwd; Vermelding - een set van een vast aantal componenten van verschillende typen; het dossier- een opeenvolging van onderdelen van hetzelfde type en dezelfde lengte. Twee meer gestructureerde typen - procedureel en type object (objectief) - zijn moeilijk te associëren met gegevens in een conventionele weergave. Foto 1- Een reeks basistypen van de Pascal-taal Het gegevenstype definieert de set toegestane waarden en de set toegestane bewerkingen. Eenvoudige soorten.
Eenvoudige typen zijn onderverdeeld in ORDINAL en REAL. 1. Ordinale typen
,
op hun beurt zijn er: een hele Pascal definieert 5 integer-typen, die worden bepaald afhankelijk van het teken en de waarde die de variabele zal aannemen. Typ naam Lengte (in bytes) Waardebereik 32
768...+32 767 2
147 483 648...+2 147 483 647 b) logisch De naam van dit type is BOOLEAN. Booleaanse waarden kunnen een van de booleaanse constanten zijn: TRUE (true) of FALSE (false). c) symbolisch De naam van dit type CHAR - neemt 1 byte in beslag. De tekentypewaarde is de verzameling van alle PK-tekens. Aan elk teken wordt een geheel getal in het bereik 0...255 toegewezen. Dit nummer dient als code voor de interne representatie van het teken. 2. ECHTE SOORTEN
.
In tegenstelling tot ordinale typen, waarvan de waarden altijd worden vergeleken met een reeks gehele getallen en daarom absoluut exact in de pc worden weergegeven, definiëren de waarden van echte typen een willekeurig getal alleen met enige eindige precisie, afhankelijk van het interne formaat van het werkelijke aantal. Lengte van numeriek gegevenstype, bytes Naam van het numerieke gegevenstype Aantal significante cijfers van een numeriek gegevenstype Decimaal exponentbereik van numeriek gegevenstype 2*1063
+1..+2*1063 -1 GESTRUCTUREERDE SOORTEN
Gestructureerde gegevenstypen definiëren een geordende reeks scalaire variabelen en worden gekenmerkt door het type van hun componenten. Gestructureerde gegevenstypen definiëren, in tegenstelling tot eenvoudige, sets van complexe waarden met één algemene naam. We kunnen zeggen dat structurele typen een bepaalde manier definiëren om nieuwe typen te vormen uit bestaande. Er zijn verschillende structureringsmethoden. Naar de wijze van organisatie en het type componenten in complexe datatypes worden de volgende varianten onderscheiden: reguliere type (arrays); gecombineerd type (records); bestandstype (bestanden); meerdere soort(en); stringtype (strings); Turbo Pascal versie 6.0 en later introduceert een objecttype (objecten). In tegenstelling tot eenvoudige gegevenstypen worden gegevens van een gestructureerd type gekenmerkt door meerdere elementen die dit type vormen, d.w.z. een variabele of constante van het gestructureerde type heeft altijd meerdere componenten. Elke component kan op zijn beurt tot een gestructureerd type behoren, d.w.z. mogelijke nesting van typen. 1. Arrays Arrays in Turbo Pascal zijn in veel opzichten vergelijkbaar met 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 elk ervan is toegankelijk door eenvoudig een serienummer op te geven. Een arraybeschrijving wordt als volgt gedefinieerd: <имя
типа>= reeks[<сп.инд.типов>] van<тип>
Hier<имя типа>- juiste identificatie; Array, of - gereserveerde woorden (array, from); <сп.инд.типов>- een lijst met een of meer indextypes gescheiden door komma's; de vierkante haken rond de lijst zijn een syntaxisvereiste; <тип>- elk type Turbo Pascal. Als indextypen in Turbo Pascal kunt u alle ordinale typen gebruiken, behalve LongInt en range-typen met het basistype LongInt. De diepte van het nesten van gestructureerde typen in het algemeen, en dus van arrays, is willekeurig, dus het aantal elementen in de lijst met type-indexen (arraydimensie) is niet beperkt, maar de totale lengte van de interne representatie van een array kan niet groter zijn dan 65520 bytes. 2. Opnamen Een record is een gegevensstructuur die bestaat uit een vast aantal componenten, de velden van een record. In tegenstelling tot een array kunnen de componenten (velden) van een record van verschillende typen zijn. Om te kunnen verwijzen naar een of ander onderdeel van het record, worden de velden benoemd. De structuur van een aangifte van het recordtype is als volgt: <
naamtype>= OPNAME<
cn.
velden>END Hier<имя типа>- juiste identificatie; RECORD, END - gereserveerde woorden (record, end); <сп.полей>- lijst met velden; is een reeks secties van een record gescheiden door een puntkomma. 3 sets Sets zijn een set van hetzelfde type logische objecten die aan elkaar gerelateerd zijn. De aard van de relaties tussen objecten wordt alleen geïmpliceerd door de programmeur en wordt op geen enkele manier gecontroleerd door Turbo Pascal. het aantal elementen in de set kan variëren van 0 tot 256 (een set die geen elementen bevat wordt leeg genoemd) Sets verschillen van arrays en records door de variabiliteit in het aantal van hun elementen. Twee verzamelingen worden als gelijkwaardig beschouwd als en slechts dan als al hun elementen hetzelfde zijn en de volgorde van de elementen van de verzameling onverschillig is. Als alle elementen van de ene set ook in een andere set zitten, zeggen we dat de eerste set in de tweede zit. De omschrijving van een settype is: <
naamtype>=SET VAN<
basissen.
type>
Hier<имя типа>- juiste identificatie; SET, OF - gereserveerde woorden (set, from); <баз.тип>- het basistype van de elementen van de verzameling, die elk ordinaal type kan zijn, behalve WOORD, INTEGER en LONGINT. Om een set te specificeren, wordt de zogenaamde setconstructor gebruikt: een lijst met specificaties van setelementen, van elkaar gescheiden door komma's; de lijst staat tussen vierkante haken. Elementspecificaties kunnen constanten of uitdrukkingen van een basistype zijn, of een bereiktype van hetzelfde basistype. 4. Bestanden Een bestand wordt opgevat als ofwel een benoemd gebied van het externe geheugen van een pc, of een logisch apparaat - een potentiële bron of ontvanger van informatie. Elk bestand heeft drie karakteristieke kenmerken het heeft een naam, waardoor het programma met meerdere bestanden tegelijk kan werken. het bevat componenten van hetzelfde type. Het componenttype kan elk type Turbo Pascal zijn, behalve bestanden. Met andere woorden, u kunt geen "bestand met bestanden" maken. de lengte van het nieuw gemaakte bestand wordt op geen enkele manier gespecificeerd wanneer het wordt gedeclareerd en wordt alleen beperkt door de capaciteit van de externe geheugenapparaten. Een bestandstype of bestandstypevariabele kan op drie manieren worden opgegeven: <
naam>= BESTAND VAN<
type>;
<
naam>=TEKST; <имя>= BESTAND; Hier<имя>- bestandstypenaam (juiste identifier); FILE, OF - gereserveerde woorden (bestand, van); TEXT is de naam van het standaard type tekstbestanden; <тип>- elk type Turbo Pascal, behalve bestanden. Afhankelijk van de aangiftemethode zijn er drie soorten bestanden te onderscheiden: Getypte bestanden (gespecificeerd door de FILE OF...-clausule); tekstbestanden (bepaald door het TEXT-type); niet-getypte bestanden (bepaald door het FILE-type). Over het converteren van numerieke gegevenstypen in Pascal
Impliciete (automatische) conversies van numerieke datatypes zijn in Pascal bijna onmogelijk. Er wordt alleen een uitzondering gemaakt voor het integer-type, dat mag worden gebruikt in expressies van het real-type. Als de variabelen bijvoorbeeld als volgt worden gedeclareerd: VarX: geheel getal; Y: echt dan de operator syntactisch correct zal zijn, hoewel een integer-expressie rechts van het toewijzingsteken staat en een reële variabele links, zal de compiler de numerieke datatypes automatisch converteren. De omgekeerde conversie automatisch van het echte type naar het gehele type is onmogelijk in Pascal. Laten we eens kijken hoeveel bytes zijn toegewezen aan variabelen van het type integer en real: 2 bytes geheugen worden toegewezen aan het integer datatype integer, en 6 bytes voor real. Er zijn twee ingebouwde functies voor het converteren van reëel naar geheel getal: round(x) rondt een reële x af op het dichtstbijzijnde gehele getal, trunc(x) kapt een reëel getal af door het fractionele deel weg te laten.Gehele gegevenstypen in Pascal
Type
Bereik
Benodigd geheugen (bytes)
byte
0..255
1
shortint
-128..127
1
geheel getal
-32768.. 32767
2
woord
0..65535
2
verlangen naar
-2147483648..2147483647
4
naam: Peter, leeftijd: 17Opmerkingen in Pascal
Echte gegevenstypen in Pascal
Type
Bereik
Benodigd geheugen (bytes)
echt
2.9*10E-39..1.7*10E38
6
enkel
1,5 * 10 E-45 .. 3,4 * 10E38
4
dubbele
5*10E-324..1.7*10E308
8
verlengd
1.9 * 10E-4951 .. 1.1 * 10E4932
10
Constanten in Pascal
1
2
3
4
5
6
const x= 17 ; var mijnnaam: tekenreeks ; begin mijnnaam: = "Peter" ; writeln ("naam: ", mijnnaam", ", leeftijd: ", x) end .
"Mooie" uitvoer van gehele getallen en reële getallen
Rekenkundige bewerkingen in Pascal
Volgorde van bewerkingen
Pascal standaard rekenkundige procedures en functies
Inc(x,n) waarbij x een ordinaal type is, n een integer type is; de procedure inc verhoogt x met n.een: =- 9 ; b:=abs(a); (b=9)
(S=breedte * dikte, V=oppervlak*hoogte)Verdeling van variabele typen
Ordinale typen
Echte typen
arrays
Inzendingen
Bestanden
Eindelijk
Type
Bereik
Mantisse, tekenen
Benodigd geheugen (bytes)
ECHT
2.9*10E-39..1.7*10E38
11-12
ENKEL
1.5*10E-45..3.4*10E38
7-8
DUBBELE
5.0*10E-324..1.7*10E308
15-16
VERLENGD
1.9*10E-4951..1.1*10E4932
19-20
COMP
-2Е+63+1..2Е+63-1
10-20
