Ordinale typen omvatten (zie figuur 4.1) gehele typen, logische typen, tekens, opgesomde typen en bereiktypen. De functie ORD(X) kan op elk van deze worden toegepast, wat terugkeert serienummer waarde van de uitdrukking X. Voor typen gehele getallen retourneert de functie ORD(X) de waarde van X zelf, d.w.z. ORD(X) = X voor X die tot een willekeurig shell-type behoort. Het toepassen van ORD(X) op boolean-, teken- en opsommingstypen levert een positief geheel getal op in het bereik van 0 tot 1 (boolean), 0 tot 155 (teken), 0 tot 65535 (opsomming). Een bereiktype behoudt alle eigenschappen van het onderliggende ordinale type, dus het resultaat van het toepassen van de ORD(X)-functie erop hangt af van de eigenschappen van dat type.

U kunt ook functies toepassen op ordinale typen:

PRED (X) - retourneert de vorige waarde van het rangtelwoordtype (de waarde die overeenkomt met het rangtelwoord ORD(X) - 1), d.w.z.

ORD(PRED(X)) = ORD(X) - 1;

SUCC(X) - retourneert volgende waarde rangtelwoordtype, dat overeenkomt met het rangtelwoord ORD(X) +1, d.w.z.

ORD(SUCC(X)) = ORD(X) + 1.

Bijvoorbeeld als een programma een variabele definieert

dan zal de functie PRED(C) de waarde "4" retourneren, en de functie SUCC(C) zal de waarde "6" retourneren.

Als we ons een ordinaal type voorstellen als een geordende reeks waarden, oplopend van links naar rechts en een bepaald segment op de getallenas bezetten, dan is de functie PRED(X) niet gedefinieerd voor links, en SUCC(X) voor rechts. einde van dit segment.

Hele soorten. Het bereik van mogelijke waarden van integer-typen hangt af van hun interne representatie, die één, twee of vier bytes kan zijn. In tabel 4.1 toont de naam van integer-typen, de lengte van hun interne representatie in bytes en het bereik van mogelijke waarden.

Tabel 4.1

Wanneer u procedures en functies met integer-parameters gebruikt, moet u zich laten leiden door het “nesten” van typen, d.w.z. overal waar WORD kan worden gebruikt, kan BYTE worden gebruikt (maar niet andersom), LONGINT “bevat” INTEGER, wat op zijn beurt SHORTINT omvat.

De lijst met procedures en functies die van toepassing zijn op typen gehele getallen wordt gegeven in Tabel 4.2. Brieven b, s, w, ik, l expressies van het type BYTE, SHORTINT, WORD, INTEGER en LONGINT worden respectievelijk aangeduid; x is een expressie van elk van deze typen; brieven vb, vs, vw, vi, vl, vx geven variabelen van de overeenkomstige typen aan. Een optionele parameter wordt tussen vierkante haakjes aangegeven.

Tabel 4.2

Standaardprocedures en functies die van toepassing zijn op hele typen
Hoger beroep	Resultaattype	Actie
buikspieren(x)	X	Retourneert module x
chr(b)	Char	Retourneert een teken op basis van zijn code
dec(vx[, ik])	-	Verlaagt de waarde van vx met i, en bij afwezigheid van i - met 1
inc(vx[, ik])	-	Verhoogt de waarde van vx met i, en bij afwezigheid van i - met 1
Hallo(ik)	Byte	Retourneert de hoge byte van het argument
Hallo(w)	Dezelfde	Dezelfde
Lo(ik)	"	Retourneert de lage byte van het argument
Laag)	"	Dezelfde
vreemd(l)	Booleaans	Retourneert True als het argument een oneven getal is
Willekeurig (w)	Hetzelfde als parameter	Retourneert een pseudowillekeurig getal dat uniform is verdeeld in het bereik 0...(w-l)
sgr(x)	X	Geeft het kwadraat van het argument terug
ruil(ik)	Geheel getal	Wisselt bytes in een woord
ruil(w)	Woord

Bij het werken met gehele getallen komt het type resultaat overeen met het type operanden, en als de operanden van verschillende typen gehele getallen zijn, het type operand dat het maximale vermogen heeft (maximaal bereik van waarden). Eventuele overloop van het resultaat wordt op geen enkele manier gecontroleerd, wat bijvoorbeeld tot misverstanden kan leiden:

a:= 32767; (Maximum mogelijke INTEGER-waarde)

x:= een + 2; (Overloop tijdens het evalueren van deze expressie !}

y:= LangeInt(a)+2; (Geen overflow na het casten van de variabele naar een krachtiger type)

SchrijfLn(x:10:0, y:10:0)

Als resultaat van het uitvoeren van het programma dat we krijgen

Booleaans type . Booleaanse waarden kunnen een van de vooraf gedeclareerde constanten FALSE of TRUE zijn. Op hen zijn de regels van toepassing:

Vals< True;

succ(False)= Waar;

pred(Waar) = Onwaar.

Omdat het Booleaanse type een ordinaal type is, kan het bijvoorbeeld in een telbare type-operator worden gebruikt:

voor 1:= Onwaar naar Waar doen ....

Karaktertype. De waarde van een tekentype is de verzameling van alle pc-tekens. Aan elk teken wordt een geheel getal in het bereik 0...255 toegewezen. Dit getal dient als de code voor de interne representatie van het symbool; het wordt geretourneerd door de ORD-functie.

Voor het coderen wordt ASCII-code gebruikt ( Amerikaanse standaard Codeer voor Informatie-uitwisseling - Amerikaans standaardcode voor informatie-uitwisseling). Dit is een 7-bits code, d.w.z. het kan worden gebruikt om slechts 128 tekens te coderen in het bereik van 0 tot 127. Tegelijkertijd kunt u in de 8-bits byte die is toegewezen voor het opslaan van een teken in Turbo Pascal tweemaal coderen meer karakters in het bereik van 0 tot 255. De eerste helft van pc-tekens met codes 0...127 komt overeen met de ASCII-standaard (Tabel 4.3). De tweede helft van de tekens met codes 128...255 wordt niet beperkt door het rigide raamwerk van de standaard en kan op een pc worden gewijzigd verschillende soorten(Bijlage 2 toont enkele algemene coderingsopties voor deze tekens).

Tabel 4.3

Tekencodering volgens de ASCII-standaard
Code	Symbool	Code	Symbool	Code	Symbool	Code	Symbool
	NUL		BL		®		"
	ZO		!		A		A
	STX		"		IN		B
	ETX		#		MET		Met
	EOT		$		D		D
	ENQ		%		E		e
	VRAGEN		&		F		F
	BEL		"		G		G
	B.S.		(		H		H
	NT		)		I		i
	LF		*		J		J
	V.T		+		k		k
	FF		,		L		i
	CR		-		M		M
	DUS		.		N		N
	SI.		/		OVER
	DEL				P		P
	DC1				Q		Q
	DC2				R		R
	DC3				S		S
	DC4				T		T
	N.A.K.				U		u
	SYN				V		V
	ETB				w		w
	KAN				X		X
	E.M.				U		U
	SUB		:		z		z
	ESC		/		[		{
	FS		<		\		l
	G.S.		=		]		}
	R.S.		>		^		~
	ONS		?		-		N

Tekens met codes 0...31 verwijzen naar servicecodes. Als deze codes worden gebruikt in de tekentekst van het programma, worden ze beschouwd als witruimte. Bij gebruik bij I/O-bewerkingen kunnen ze de volgende onafhankelijke betekenis hebben:

Symbool	Code	Betekenis
BEL		Telefoongesprek; De weergave van dit symbool gaat gepaard met geluidssignaal
NT		Horizontale tabellering; wanneer weergegeven op het scherm, verplaatst de cursor naar een positie die een veelvoud is van 8 plus 1 (9, 17, 25, enz.)
LF		Lijnvoeding; bij weergave op het scherm worden alle volgende tekens weergegeven vanaf dezelfde positie, maar op volgende regel
V.T		Verticaal tabblad; wanneer het op het scherm wordt weergegeven, wordt het vervangen speciaal teken
FF		Pagina uitvoeren; bij uitvoer naar een printer vormt het een pagina; bij uitvoer naar het scherm wordt het vervangen door een speciaal teken
CR		Vervoer retour; ingevoerd door op te drukken Voer sleutel in(indien ingevoerd met READ of READLN, betekent dit het commando "Enter" en past het niet in de invoerbuffer; bij uitvoer betekent dit het commando "Ga door met uitvoeren vanaf het begin" huidige lijn»)
SUB		Einde bestand; ingevoerd vanaf het toetsenbord door op Ctrl-Z te drukken; bij uitvoer wordt het vervangen door een speciaal teken
SSC		Einde van de werkzaamheden; ingevoerd via het toetsenbord door op te drukken ESC-toets; bij uitvoer wordt het vervangen door een speciaal teken

Relationele bewerkingen, evenals ingebouwde functies, zijn van toepassing op het CHAR-type: СНR(В) - functie van het CHAR-type; converteert een uitdrukking B van het type BYTE in een teken en retourneert dit met zijn waarde;

UPCASE(CH) - CHAR-type functie; retourneert hoofdletter, als CH kleine letters is Latijnse brief, retourneert anders het CH-teken zelf, bijvoorbeeld:

cl:= UpCase("s" );

c2:= UpCase ("Ф" );

SchrijfLn(cl," ",c2)

Omdat de UPCASE-functie Cyrillisch niet verwerkt, is het resultaat van het uitvoeren hiervan

programma's worden op het scherm weergegeven

Enum-type. Een opgesomd type wordt gespecificeerd door een opsomming van de waarden die het kan ontvangen. Elke waarde wordt benoemd door een identificatie en bevindt zich in een lijst omgeven door haakjes, bijvoorbeeld:

kleuren =(rood, wit, blauw);

Het gebruik van opgesomde typen maakt programma's visueler. Als het programma bijvoorbeeld gegevens gebruikt die verband houden met de maanden van het jaar, dan is het volgende fragment van het programma:

TypeMaand=(januari,februari,maart,april,mei,juni,juli,aug,september,oktober,november,dec);

maand: TypeMaand;

if month = Aug then WriteLn("Het zou leuk zijn om naar de zee te gaan!");

Het zou, ziet u, heel duidelijk zijn. Helaas! In Turbo Pascal kun je geen Cyrillisch gebruiken in identificatiegegevens, dus zijn we genoodzaakt om als volgt te schrijven:

TypeMaand=(jan,feb,maart,mei,juni,jul,aug,sep,okt,nov,dec);

maand: TypeMaand;

if month = aug then WriteLn("Het zou leuk zijn om naar de zee te gaan!");

De overeenkomst tussen de waarden van een opgesomd type en de rangtelwoorden van deze waarden wordt vastgesteld door de opsommingsvolgorde: de eerste waarde in de lijst krijgt het rangtelwoord 0, de tweede - 1, enz. De maximale capaciteit van een opgesomd type is 65536 waarden, dus in feite definieert een opgesomd type een bepaalde subset van het hele WORD-type 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 doordat u de waarden kunt controleren die overeenkomstige variabelen ontvangen. Laat bijvoorbeeld de volgende opgesomde typen worden gegeven:

kleuren = (zwart, rood, wit);

ordenal= (één, twee, drie);

dagen = (maandag, dinsdag, woensdag);

In termen van macht en interne representatie zijn alle drie de typen gelijkwaardig:

ord(zwart)=0, ..., ord(wit)=2,

ord(één)=0, ...ord(drie)=2,

ord(maandag)=0, ...ord(woensdag)=2.

Als de variabelen echter zijn gedefinieerd

kleur:kleuren; num: ordinaal;

dan zijn de operators toegestaan

num:= succ(twee);

dag:= pred(dinsdag);

maar onaanvaardbaar

Zoals eerder vermeld, is er een één-op-één-correspondentie tussen de waarden van een opgesomd type en de reeks gehele getallen, gespecificeerd door de ORD(X)-functie. Bij Turbo Pascal kan het ook omgekeerde conversie: Elke expressie van het type WORD kan worden geconverteerd naar een waarde van een opsommingstype, zolang de waarde van de integer-expressie de power1™ van het opsommingstype niet overschrijdt. Deze conversie wordt bereikt door gebruik te maken van een automatisch gedeclareerde functie met de naam van het opgesomde type (zie paragraaf 4.4). Voor de hierboven besproken typedeclaratie zijn bijvoorbeeld de volgende toewijzingen gelijkwaardig:

kleur:= kleuren(0);

Natuurlijk, opdracht

zal onaanvaardbaar zijn.

Variabelen van elk opgesomd type kunnen worden gedeclareerd zonder eerst dat type te declareren, bijvoorbeeld:

kleur: (zwart, wit, groen);

Type-bereik. Een bereiktype is een subset van het basistype, dat elk ordinaal type kan zijn, behalve een bereiktype. Een bereiktype wordt gedefinieerd door de grenzen van zijn waarden binnen het basistype:

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

Hier<мин.знач. > - minimale waarde type-bereik;

<макс.знач.>- de maximale waarde ervan.

Bijvoorbeeld:

cijfer = "0".."9";

Het bereiktype hoeft niet te worden beschreven in de sectie TYPE, maar kan direct worden opgegeven bij het declareren van een variabele, bijvoorbeeld:

Ichr: "A".."Z";.

Bij het bepalen van het typebereik moet men zich laten leiden door de volgende regels:

• twee ".."-tekens worden als één teken behandeld, dus spaties ertussen zijn niet toegestaan;
• de linkerrand van het bereik mag de rechterrand niet overschrijden. Een bereiktype erft alle eigenschappen van zijn basistype, maar met de beperkingen van zijn lagere vermogen. In het bijzonder als er een variabele is gedefinieerd

dagen = (ma,di,wo,th,fr,sa,su);

Weekend = za .. zo;

dan zal ORD(W) de waarde 5 retourneren, terwijl PRED(W) een fout zal opleveren.

IN standaard bibliotheek Turbo Pascal bevat twee functies die het werken met bereiktypen ondersteunen:

HOOG(X) - retourneert maximale waarde het bereiktype waartoe de variabele X behoort;

LAAG(X) - retourneert de minimumwaarde van het bereiktype.

Volgende kort programma zal de lijn weergeven

WriteLn(Laag(k),"..",Hoog(k))

De reeks gehele getallen is oneindig, maar we kunnen altijd een aantal bits kiezen om elk geheel getal weer te geven dat ontstaat bij het oplossen specifieke taak. De reeks reële getallen is niet alleen oneindig, maar ook continu, dus hoeveel bits we ook nemen, we zullen onvermijdelijk getallen tegenkomen die geen exacte representatie hebben. Drijvende-kommagetallen zijn er één van mogelijke manieren weergave van reële getallen, wat een afweging is tussen nauwkeurigheid en bereik van geaccepteerde waarden.

Een getal met drijvende komma bestaat uit een reeks individuele cijfers, conventioneel verdeeld in teken, exponent en mantisse. De exponent en mantisse zijn gehele getallen die, samen met het teken, de volgende weergave van een drijvende-kommagetal geven:

Wiskundig gezien wordt het als volgt geschreven:

(-1) s × M × B E, waarbij s het teken is, B de wortel is, E de exponent is en M de mantisse is.

De basis bepaalt het cijfersysteem. Het is wiskundig bewezen dat drijvende-kommagetallen met grondtal B=2 (binaire representatie) het meest resistent zijn tegen afrondingsfouten, daarom komen we in de praktijk alleen grondtal 2 en, minder gebruikelijk, 10 tegen. Voor verdere presentatie gaan we altijd uit van B= 2, en de formule voor een getal met drijvende komma ziet er als volgt uit:

(-1) s × M × 2 E

Wat is mantisse en orde? Mantisse is een geheel getal met een vaste lengte dat de meest significante bits van een reëel getal vertegenwoordigt. Laten we zeggen dat onze mantisse uit drie bits bestaat (|M|=3). Neem bijvoorbeeld het getal “5”, dat binair systeem zal gelijk zijn aan 101 2. Het meest significante bit komt overeen met 2 2 =4, het middelste bit (wat we hebben). gelijk aan nul) 2 1 =2, en de jongste 2 0 =1. Volgorde– dit is de macht van het grondtal (twee) van het hoogste cijfer. In ons geval E=2. Het is handig om dergelijke getallen in de zogenaamde ‘wetenschappelijke’ te schrijven standaard formulier, bijvoorbeeld "1.01e+2". Het is meteen duidelijk dat de mantisse uit drie tekens bestaat, en de volgorde is twee.

Laten we zeggen dat we willen krijgen fractioneel getal, met dezelfde 3 stukjes van de mantisse. Dit kunnen we doen als we bijvoorbeeld E=1 nemen. Dan zal ons aantal gelijk zijn

1,01e+1 = 1×2 1 +0×2 0 +1×2 -1 =2+0,5=2,5

Het is duidelijk dat op deze manier hetzelfde getal op verschillende manieren kan worden weergegeven. Laten we een voorbeeld bekijken met de lengte van de mantisse |M|=4. Het getal “2” kan als volgt worden weergegeven:

2 = 10 (in binair getal) = 1.000e+1 = 0.100e+2 = 0.010e+3.

Daarom waren al in de allereerste machines getallen vertegenwoordigd in de zogenaamde genormaliseerde vorm, toen er altijd werd aangenomen dat het eerste stukje van de mantisse gelijk was aan één.

Dit bespaart één bit (aangezien de impliciete niet in het geheugen hoeft te worden opgeslagen) en zorgt ervoor dat het getal uniek wordt weergegeven. In ons voorbeeld heeft “2” één enkele representatie (“1.000e+1”) en wordt de mantisse in het geheugen opgeslagen als “000”, omdat de leidende eenheid wordt impliciet geïmpliceerd. Maar in de genormaliseerde weergave van getallen ontstaat er nieuw probleem- het is onmogelijk om nul in deze vorm weer te geven.

Gegevensanalyse met behulp van de opdrachten Parameterselectie en Oplossing zoeken

Analyse en interpretatie van experimenteel psychologische onderzoeksgegevens.

Analyse van brongegevens. Technische normen voor stadswegen.

ANALYSE VAN VERKREGEN GEGEVENS. EEN BESLISSING NEMEN OVER DE VOLDOENDE OF ONTOEREIKENDE KENMERKEN VAN DE WATERVOORZIENING VOOR DE BEHOEFTEN VAN HET IRRIGATIESYSTEEM.

Communicatielijnapparatuur: datatransmissieapparatuur, eindapparatuur, tussenapparatuur.

Een gegevenstype definieert een reeks geldige waarden en een reeks geldige bewerkingen.

Eenvoudige typen.

Eenvoudige typen zijn onderverdeeld in ORDINAL en REAL.

1. BESTELTYPEN , op hun beurt zijn er:

a) geheel

Pascal definieert 5 typen gehele getallen, die worden bepaald afhankelijk van het teken en de waarde die de variabele zal aannemen.

Typ naam	Lengte (in bytes)	Bereik van waarden
		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 logische constanten zijn: TRUE (waar) of FALSE (onwaar).

c) symbolisch

De naam van dit type is CHAR - beslaat 1 byte. De waarde van een tekentype is de verzameling van alle pc-tekens. Aan elk teken wordt een geheel getal in het bereik 0…255 toegewezen. Dit nummer dient als code voor de interne weergave van het symbool.

2. ECHTE SOORTEN .

In tegenstelling tot ordinale typen, waarvan de waarden altijd worden toegewezen aan een reeks gehele getallen en daarom absoluut nauwkeurig worden weergegeven op de pc, definiëren de waarden van reële typen willekeurig nummer alleen met enige eindige precisie, afhankelijk van het interne formaat van het reële getal.

Lengte van numeriek gegevenstype, bytes	Naam van numeriek gegevenstype	Hoeveelheid significante cijfers numeriek gegevenstype	Decimaal ordebereik van een numeriek gegevenstype
			2*1063 +1..+2*1063 -1

GESTRUCTUREERDE TYPEN

Gestructureerde gegevenstypen definiëren een geordende verzameling scalaire variabelen en worden gekenmerkt door het type van hun componenten.

Gestructureerde gegevenstypen definiëren, in tegenstelling tot eenvoudige, veel complexe waarden met één gemeenschappelijke naam. We kunnen zeggen dat structurele typen een bepaalde manier bepalen om nieuwe typen uit bestaande te vormen.

Er zijn verschillende structureringsmethoden. Volgens de organisatiemethode en het type componenten in complexe gegevenstypen worden de volgende varianten onderscheiden: regulier type (arrays); gecombineerd type (records); bestandstype(bestanden); meerdere type(n); tekenreekstype(tekenreeksen); in de Turbo Pascal-taalversie 6.0 en ouder werd een objecttype (objecten) geïntroduceerd.

In tegenstelling tot eenvoudige gegevenstypen worden gestructureerde gegevens gekenmerkt door de veelheid aan elementen waaruit dit type bestaat, d.w.z. een variabele of constante van een gestructureerd type heeft altijd meerdere componenten. Elke component kan op zijn beurt tot een gestructureerd type behoren, d.w.z. Nesten van typen is mogelijk.

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 (mogelijk gestructureerd). Deze componenten kunnen eenvoudig worden georganiseerd en elk ervan is eenvoudig toegankelijk door een serienummer op te geven.

De arraybeschrijving wordt als volgt gespecificeerd:

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

Hier<имя типа>- correcte identificatie;

Array, van – gereserveerde woorden(matrix, van);

<сп.инд.типов>- een lijst met een of meer indextypen, gescheiden door komma's; vierkante haken die de lijst omlijsten zijn een syntaxisvereiste;

<тип>- elk type Turbo Pascal.

Alle ordinale typen kunnen worden gebruikt als indextypen in Turbo Pascal, behalve LongInt en bereiktypen met basistype LangeInt.

De nestdiepte van gestructureerde typen in het algemeen, en dus van arrays, is willekeurig, dus het aantal elementen in de lijst met type-indexen (arraygrootte) is niet beperkt. De totale lengte van de interne representatie van een array kan echter niet groter zijn dan 65520 bytes.

2. Registratie

Een record is een gegevensstructuur die bestaat uit een vast aantal componenten die recordvelden worden genoemd. In tegenstelling tot een array kunnen de componenten (velden) van een record dat wel zijn verschillende soorten. Om het mogelijk te maken naar een of ander onderdeel van een record te verwijzen, zijn de velden benoemd.

De structuur van een berichttypedeclaratie is:

< Naamtype>=OPNAME< joint venture. velden>EIND

Hier<имя типа>- correcte identificatie;

RECORD, END – gereserveerde woorden (record, end);

<сп.полей>- lijst met velden; is een reeks secties van een record, gescheiden door een puntkomma.

3. Stelt in

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

Twee sets worden als gelijkwaardig beschouwd als en slechts als al hun elementen hetzelfde zijn en de volgorde van de elementen van de set onverschillig is. Als alle elementen van de ene set ook in een andere set zijn opgenomen, wordt gezegd dat de eerste set in de tweede is opgenomen.

De omschrijving van het settype is:

< Naamtype>=SET VAN< basen. type>

Hier<имя типа>- correcte identificatie;

SET, OF – gereserveerde woorden (set, from);

<баз.тип>- het basistype van set-elementen, dat elk ordinaal type kan zijn, behalve WORD, INTEGER en LONGINT.

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

4. Bestanden

Een bestand verwijst naar een benoemd gebied extern geheugen Een pc of logisch apparaat is 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 Turbo Pascal-type zijn, behalve bestanden. Met andere woorden: u kunt geen ‘bestand met bestanden’ maken.

weer lengte aangemaakt bestand wordt op geen enkele manier gespecificeerd wanneer het wordt aangekondigd en wordt alleen beperkt door de capaciteit van externe geheugenapparaten.

Bestandstype of variabele bestandstype kan op drie manieren worden ingesteld:

< Naam>= BESTAND VAN< type>;

< Naam>=TEKST;

<имя>= BESTAND;

Hier<имя>- bestandstypenaam (juiste identificatie);

FILE, OF – gereserveerde woorden (bestand, van);

TEXT – naam van het standaard tekstbestandstype;

<тип>- elk type Turbo Pascal, behalve bestanden.

Afhankelijk van de wijze van aangifte kunnen drie soorten bestanden worden onderscheiden:

· getypte bestanden (ingesteld door de FILE OF...-clausule);

· tekstbestanden(gedefinieerd door type TEKST);

· ongetypeerde bestanden (gedefinieerd door het FILE-type).

Over de conversie numerieke typen Pascal-gegevens

In Pascal zijn impliciete (automatische) conversies van numerieke gegevenstypen vrijwel onmogelijk. Er wordt alleen een uitzondering gemaakt voor het type geheel getal, dat mag worden gebruikt in expressies van het type real. Als de variabelen bijvoorbeeld als volgt worden gedeclareerd:

Var X: geheel getal; Y: echt;

dan de exploitant

zal syntactisch correct zijn, hoewel er rechts van het toewijzingsteken een integer-expressie staat en links een echte variabele, zal de compiler numerieke gegevenstypen automatisch converteren. De omgekeerde conversie vindt automatisch plaats van echt type naar geheel getaltype onmogelijk bij Pascal. Laten we onthouden hoeveel bytes zijn toegewezen aan variabelen van het type geheel getal en real: for geheel getaltype Er wordt 2 bytes geheugen toegewezen voor gehele gegevens en 6 bytes voor echte gegevens. 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ële waarde af door het fractionele deel weg te gooien.

Gegevenstype

Typecompatibiliteit

Geconstrueerde gegevenstypen

Echte gegevenstypen

Ordinale typen gegevens

Gegevenstype

Plan

Lezing 8

Onderwerp: Gegevenstype

Samenstellers Pascal-taal vereisen dat informatie over de hoeveelheid geheugen die nodig is om een ​​programma uit te voeren, wordt verstrekt voordat het wordt gestart. Om dit te doen, moet u in de variabelebeschrijvingssectie (var) alle variabelen vermelden die in het programma worden gebruikt. Bovendien moet u de compiler ook vertellen hoeveel geheugen elk van deze variabelen in beslag zal nemen. Het zou ook fijn zijn om vooraf afspraken te maken diverse operaties, van toepassing op bepaalde variabelen...

Dit alles kan aan het programma worden doorgegeven door eenvoudigweg het type toekomstige variabele aan te geven. Met informatie over het type variabele, 'begrijpt' de compiler hoeveel bytes ervoor moeten worden toegewezen, welke acties ermee kunnen worden uitgevoerd en aan welke constructies hij kan deelnemen.

Type definieert set aanvaardbare waarden, die dit of dat object kan hebben, evenals de reeks geldige bewerkingen die erop van toepassing zijn. Bovendien bepaalt het type ook het formaat van de interne weergave van gegevens in het pc-geheugen.

De basisgegevenstypen zijn standaard, dus het is niet nodig deze in de typesectie te beschrijven. Desgewenst kan dit echter ook door bijvoorbeeld lange definities te geven korte namen. Laten we zeggen door binnen te komen nieuw type gegevens

Type Int = geheel getal;

U kunt de programmatekst iets inkorten.

De indeling in basis- en geconstrueerde gegevenstypen in Pascal wordt weergegeven in de tabel:

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

1. Elk element van een rangtelwoordtype kan worden geassocieerd met een uniek (rangtelwoord) getal. De nummering van waarden begint vanaf nul. De uitzondering vormen de gegevenstypen ShortInt, Integer en LongInt. Hun nummering valt samen met de waarden van de elementen.

2. Bovendien is er voor elementen van elk ordinaal type een gedefinieerde volgorde (in de wiskundige zin van het woord), die rechtstreeks afhangt van de nummering. Dus voor twee elementen van een ordinaal type kan men precies zeggen welke kleiner is en welke groter is dan 2.

D Pascal breidt CF Pascal aanzienlijk uit door nieuwe gegevenstypen toe te voegen aan symbolen en bestanden. Ordinale gegevenstypen beschrijven eenvoudige, ondeelbare objecten. Een opsommingstype bevat een vaste set benoemde objecten. Het Booleaanse type heeft slechts twee objecten: TRUE en FALSE. Type geheel getal implementeert positieve en negatieve gehele getallen. Tenslotte kan een deel van een type ook weer een type zijn, een rangetype. Typen omvatten uiteraard bewerkingen die definiëren wat er met objecten kan worden gedaan. Voor logisch, geheel getal, etc. deze handelingen worden intuïtief goed begrepen.

Gegevenstypen beschrijven waardensets en de bewerkingen die daarop kunnen worden toegepast. De door CF Pascal geïntroduceerde gegevenstypen zijn CHAR en TEXT. Waarden van het type CHAR zijn de set geldige Pascal-symbolen, en bewerkingen op deze waarden zijn vergelijkingsoperatoren:

= < > <= >= <>

waarvan de waarden overeenkomen wiskundige bewerkingen, wat de verschillende posities van karakters in de alfabetische volgorde weerspiegelt. TEXT-gegevenstypewaarden zijn reeksen tekenreeksen, waarbij elke regel een reeks tekens is. Bewerkingen op dergelijke gegevens:

RESET HERSCHRIJVEN LEZEN SCHRIJVEN SCHRIJVEN OEF EOLN

Gegevenstypen bieden voordelen abstractie, replicatie En authenticatie.

Gegevenstypen abstraheren belangrijke eigenschappen van gegevens. Om bijvoorbeeld de vergelijking te begrijpen

'A'< ‘B’

het is niet nodig om te weten hoe deze symbolen worden weergegeven in de Pascal-machine. De sorteervolgorde bepaalt de betekenis van deze bewerkingen. De gebruiker hoeft niet te weten hoeveel bits de tekenwaarde vertegenwoordigen, wat er met de overtollige bits gebeurt en of de bitwaarde voor het teken geldig is B meer dan voor A enz.

Modules bieden een soort data-abstractie, maar datatypen bieden meer dan dat. Door variabelen van het gegevenstype te declareren, kunt u via deze variabelen een willekeurig aantal waarden van het type opslaan en manipuleren. Elk gebruik van een variabele in een programma geeft ons de garantie dat er alleen geldige bewerkingen op zullen worden toegepast.

De context van een operand in een programma impliceert het type van de operand; dit impliciete type is redundante informatie die kan worden gecontroleerd aan de hand van het aangegeven type van de operand om bewerkingen op waarden van het verkeerde type te voorkomen. Beschouw het volgende programmafragment:

PROGRAMMA Typex(INVOER, UITVOER);

Omdat de =-bewerking in CF Pascal alleen voor karakteroperands is gedefinieerd, impliceert het verschijnen van Ch en F als operanden dat ze beide CHAR-typen zijn. Ch is correct getypt, maar F wordt gedeclareerd als TEXT, dus er zal een mismatch worden gedetecteerd.

Er zijn twee soorten gegevenstypen in D Pascal: eenvoudige gegevenstypen en geaggregeerde gegevenstypen. Waarden van eenvoudige typen kunnen niet zijn samengesteld uit kleinere delen die afzonderlijk kunnen worden gemanipuleerd. CHAR is een eenvoudig type. Waarden van complexe gegevenstypen worden gevormd door waarden van eenvoudige typen te combineren. TEKST – samengestelde soort, omdat bestandsregels uit tekens bestaan.

Waarden van eenvoudige typen zijn geordend, dat wil zeggen dat voor elk paar waarden van dit type x, y slechts één van de opties mogelijk is: x< y, x = y, x >j. Daarom worden deze typen ordinaal genoemd.

Pascal bevat drie vooraf gedefinieerde ordinale typen, die worden gespecificeerd door de identificatiegegevens CHAR, INTEGER en BOOLEAN. Naast de vooraf gedefinieerde rangtelwoorden biedt Pascal twee methoden waarmee de programmeur nieuwe rangtelwoorden kan definiëren, namelijk:

1. Opgesomde typen waarvan de waarden unieke identificatiegegevens zijn.
2. Bereiktypen waarvan de waarden opeenvolgende waarden zijn van een ander ordinaal type.

Dat wil zeggen dat nieuwe ordinale gegevenstypen kunnen worden gedefinieerd door de constanten van het type op te sommen of door te specificeren dat de waarden van het type een subbereik van waarden zijn. bestaande soort. De syntaxis voor het aanduiden van dergelijke ordinale typen is als volgt:

<обозначение типа> ::= <идентификатор типа> | <новый тип>

<идентификатор типа> ::= <идентификатор>

<новый тип> ::= <перечислимый тип> | <тип диапазон>

Beschrijving methoden voor<перечислимый тип>En<тип диапазон>zullen in de relevante paragrafen hieronder worden gegeven.

Wanneer een nieuw type wordt gedefinieerd, kan dit een naam krijgen in de typedeclaratie. Deze declaratie moet voorafgaan aan de declaratie van blokvariabelen.

<блок> ::= <раздел объявлений типов> <раздел объявлений переменных>

<раздел объявлений процедур> <раздел операторов>

<раздел объявлений типов>::= TYPE<объявления типов> |

Deze regel laat dat zien<раздел объявлений типов>mag leeg zijn (zoals voorheen het geval was in alle programma's). deze plek)

<объявления типов> ::= <объявления типов> <объявление типа> | <объявление типа>

<объявление типа> ::=<идентификатор > = <обозначение типа>

De contextregel die bij deze syntaxisregels hoort, stelt dat slechts enkele identifiers dat zijn<объявлением типа>:

CR Te gebruiken als<идентификатор типа>, <идентификатор>moet eerder zijn verschenen<объявлениях типов>.

Dus voor

zowel T1 als T2 zijn type-ID's en kunnen in het huidige blok worden gebruikt om variabelen en formele parameters te declareren, zoals CHAR eerder werd gebruikt.

In Pascal-taal variabelen worden gekenmerkt door hun type. Een type is een eigenschap van een variabele waardoor een variabele veel waarden kan aannemen die door dat type zijn toegestaan ​​en kan deelnemen aan veel bewerkingen die op dat type zijn toegestaan.

Een type definieert de set geldige waarden die een variabele kan aannemen. van dit type. Het definieert ook de reeks geldige bewerkingen op een variabele van een bepaald type en definieert gegevensrepresentaties in RAM computer.

Bijvoorbeeld:

n: geheel getal;

Pascal is een statische taal, wat betekent dat het type van een variabele wordt bepaald wanneer deze wordt gedeclareerd en niet kan worden gewijzigd. De Pascal-taal heeft een ontwikkeld typesysteem: alle gegevens moeten vooraf eigendom zijn bekende soort gegevens (een standaardtype gemaakt tijdens de taalontwikkeling of een aangepast type dat door de programmeur is gedefinieerd). De programmeur kan zijn eigen typen creëren met een willekeurige complexiteitsstructuur standaard typen, of al gebruiker gedefinieerd typen. Hoeveelheid gecreëerde typen onbeperkt. Aangepaste typen in een programma worden gedeclareerd in de sectie TYPE met behulp van het formaat:

[naam] = [type]

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

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

Gestructureerde typen zijn volgens bepaalde regels gebouwd uit eenvoudige typen.

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

Procedurele typen zijn een innovatie in de Turbo Pascal-taal en zorgen ervoor dat subroutines toegankelijk zijn alsof het variabelen zijn.

Objecten zijn ook een innovatie en zijn bedoeld om de taal als objectgeoriënteerde taal te gebruiken.

In de Pascal-taal zijn er 5 soorten gehele typen. Elk van hen karakteriseert het bereik van geaccepteerde waarden en de ruimte die ze in het geheugen innemen.

Wanneer u gehele getallen gebruikt, 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. Bytetype kan in alle typen worden genest en 2 en 4 bytes bezetten. Tegelijkertijd Kort type Een int die 1 byte beslaat, kan niet worden genest Woordtype, omdat het geen negatieve waarden heeft.

Er zijn 5 echte typen:

Integer-typen worden absoluut nauwkeurig weergegeven in een computer. In tegenstelling tot typen met gehele getallen 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 in een computer weergegeven als een vast of zwevend komma.

2358.8395

0.23588395*10 4

0,23588395*E 4

Het Comp-type neemt een speciale positie in Pascal in; het is in feite een groot geheel getal met teken. Dit type is compatibel met alle reële typen en kan worden gebruikt voor een groot geheel getal. Bij presentatie echte cijfers drijvende punt decimaal punt, wordt altijd vóór de linker of hoge mantisse geïmpliceerd, maar bij operatie op een nummer wordt deze naar links of rechts verschoven.

Ordinale typen

Ordinale typen combineren verschillende eenvoudige typen. Deze omvatten:

• alle typen gehele getallen;
• karaktertype;
• Booleaans type;
• type-bereik;
• 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 nummer, dat een serienummer is, worden gekoppeld; aangrenzende waarden van ordinale typen verschillen met één.

Voor waarden van een rangtelwoordtype kan de functie ODD(x) worden toegepast, die het rangtelwoord van het argument x retourneert.

Functie PRED(x) - retourneert de vorige waarde van een ordinaal type. PRED(A) = 5.

SUCC(x)-functie - retourneert de volgende ordinale waarde. SUCC(A) = 5.

Karaktertype

Waarden van het tekentype zijn 256 tekens uit de set geldige tekens code tabel de computer die u gebruikt. Het begingebied van deze set, dat wil zeggen het bereik van 0 tot 127, komt overeen met de set ASCII-codes, waarin de alfabettekens, Arabische cijfers en speciale tekens worden geladen. Startgebiedtekens zijn altijd aanwezig op het pc-toetsenbord. Het seniorengebied wordt alternatief genoemd en bevat symbolen van nationale alfabetten en verschillende speciale karakters en niet-ASCII-pseudografische tekens.

Een tekentypewaarde neemt één byte RAM in beslag. In het programma zijn de betekenissen tussen apostrofs geplaatst. Waarden kunnen ook worden opgegeven in de vorm van hun ASCII-code. In dit geval moet u een #-teken vóór het nummer met de symboolcode plaatsen.

C:= 'EEN'

Logisch (Booleaans) type

Er zijn twee Booleaanse waarden: True en False. Variabelen van dit type worden gespecificeerd met behulp van het BOOLEAN-functiewoord. Booleaanse waarden bezetten één byte in RAM. De waarden True en False komen overeen numerieke waarden 1 en 0.

Type-bereik

Er is een subset van het basistype, die elk ordinaal type kan zijn. Een bereiktype wordt gedefinieerd door de grenzen binnen het basistype.

[minimumwaarde]…[maximumwaarde]

Het bereiktype kan worden opgegeven in de sectie Type als bepaald type, of rechtstreeks in de Var-sectie.

Bij het bepalen van het typebereik moet u zich laten leiden door:

• de linkerrand mag de rechterrand niet overschrijden;
• een bereiktype erft alle eigenschappen van het basistype, maar met beperkingen die verband houden met het lagere vermogen ervan.

Enum-type

Dit type behoort tot ordinale typen en wordt gespecificeerd door de waarden op te sommen die het kan opsommen. Elke waarde wordt een bepaalde identificatie genoemd en bevindt zich in de lijst, tussen haakjes. Het opgesomde type wordt gespecificeerd in Type:

Volkeren = (mannen, vrouwen);

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

Maximaal vermogen 65535 waarden.

Tekenreekstype

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

In een programma wordt een stringtype gedeclareerd met het woord String. Omdat String een basistype is, wordt het in de taal gedefinieerd en gedeclareerd variabel type String is geïmplementeerd in Var. Bij het declareren van een variabele tekenreekstype Het is raadzaam om de lengte van de string achter String tussen vierkante haken aan te geven. Ter indicatie wordt een geheel getal van 0 tot 255 gebruikt.

Fam: Snaar;

Door de tekenreekslengte op te geven, kan de compiler het opgegeven aantal bytes in RAM voor deze variabele toewijzen. Als de lengte van de string niet is gespecificeerd, wijst de compiler het maximaal mogelijke aantal bytes (255) toe voor de waarde van deze variabele.