Ang pinakakaraniwan sa matematika mga uri ng numero- Ito buo mga numero na kumakatawan sa isang walang katapusang bilang ng mga discrete value, at wasto mga numero na kumakatawan sa isang walang limitasyong continuum ng mga halaga.

Paglalarawan ng mga numeric na uri ng data ng Pascal (mga integer)

Sa loob ng parehong wika, maaaring ipatupad ang iba't ibang subset ng hanay ng mga integer. Ang hanay ng mga posibleng halaga ng mga uri ng integer na numero ay nakasalalay sa kanilang panloob na representasyon, na maaaring isa, dalawa, o apat na byte. Kaya, sa Pascal 7.0 ang mga sumusunod na integer numeric na uri ng data ay ginagamit:

Nang buo numeric na mga uri ng data Magagawa ni Pascal ang mga sumusunod na operasyon:

• Arithmetic:
  karagdagan(+);
  pagbabawas (-);
  multiplikasyon(*);
  natitira sa dibisyon (mod);
  exponentiation;
  unary plus (+);
  unary minus (-).

• Mga pagpapatakbo ng kaugnayan:
  ugnayang pagkakapantay-pantay (=);
  ugnayang hindi pagkakapantay-pantay (<>);
  mas mababa ang ratio (<);
  ratio na mas malaki kaysa sa (>);
  kaugnayan na hindi bababa sa (>=);
  wala na ang ugali (<=).

Kapag kumikilos kasama integer numeric na mga uri ng data ang uri ng resulta ay tumutugma sa uri ng mga operand, at kung ang mga operand ay may iba't ibang uri ng integer, sa uri ng operand na may pinakamataas na kapangyarihan (maximum na hanay ng mga halaga). Ang posibleng pag-apaw ng resulta ay hindi kinokontrol sa anumang paraan (ito ay mahalaga!) , na maaaring humantong sa mga error.

Ang partikular na atensyon ay dapat bayaran sa pagpapatakbo ng paghahati ng mga integer numeric na uri ng data. Pinapayagan ng Pascal ang dalawang operasyon ng dibisyon, na tinukoy nang naaayon "/" At div. Kailangan mong malaman na ang resulta ng dibisyon "/" ay hindi isang integer, ngunit tunay na numero(ito ay totoo kahit na hatiin mo ang 8 sa 2, ibig sabihin, 8/2=4.0). Ang division div ay integer division, ibig sabihin. Ang uri ng resulta ay integer.

Paglalarawan ng mga numeric na uri ng data (real) ni Pascal

Ang totoong numeric na uri ng data ay tumutukoy sa isang subset ng mga tunay na numero na maaaring katawanin sa tinatawag na format ng floating point na may nakapirming bilang ng mga digit. Sa pamamagitan ng lumulutang na punto, ang bawat numeric na uri ng data ay kinakatawan bilang dalawang pangkat ng mga digit. Ang unang pangkat ng mga numero ay tinatawag na mantissa, ang pangalawa ay ang exponent. Sa pangkalahatan, ang isang numeric na uri ng data sa floating point form ay maaaring katawanin tulad ng sumusunod: X= (+|-)MP (+ | -) r, kung saan ang M ay ang mantissa ng numero; r – pagkakasunud-sunod ng numero (r – integer); P – base ng sistema ng numero. Halimbawa, para sa decimal na base, ang representasyong 2E-1 (narito ang E ang base ng sistema ng decimal na numero) ay magiging ganito: 2*10 -1 =0.2, at ang representasyong 1.234E5 ay tumutugma sa: 1.234*10 5 =123400.0.

Ginagamit ni Pascal ang mga sumusunod na uri ng totoong numero, na tumutukoy sa isang arbitraryong numero lamang na may ilang tiyak na katumpakan depende sa panloob na format ng tunay na numero:

Kapag naglalarawan ng isang tunay na variable ng uri ng tunay, isang variable na 4 bytes ay malilikha sa memorya ng computer. Sa kasong ito, 3 byte ang ibibigay para sa mantissa, at isang byte para sa order.

Ang mga sumusunod na operasyon ay maaaring isagawa sa mga totoong numeric na uri ng data:

• Arithmetic:
  karagdagan (+);
  pagbabawas (-);
  multiplikasyon(*);
  dibisyon(/);
  exponentiation;
  unary plus (+);
  unary minus (-).

• Mga pagpapatakbo ng kaugnayan:
  ugnayang hindi pagkakapantay-pantay (<>);
  mas mababa ang ratio (<);
  ratio na mas malaki kaysa sa (>);
  kaugnayan na hindi bababa sa (>=);
  wala na ang ugali (<=).

Tulad ng nakikita mo, ang Pascal ay nailalarawan sa pamamagitan ng isang mayamang hanay ng mga tunay na uri, ngunit ang pag-access sa mga numeric na uri ng data walang asawa, doble At pinahaba posible lamang sa ilalim ng mga espesyal na mode ng compilation. Ang mga numeric na uri ng data na ito ay idinisenyo para sa suporta sa hardware para sa floating-point arithmetic, at para epektibong magamit ang mga ito, dapat may kasamang math coprocessor ang iyong PC.

Ang numeric na uri ng data ay sumasakop sa isang espesyal na posisyon sa Pascal. comp, na itinuturing bilang isang tunay na numero na walang exponential at fractional na bahagi. Sa totoo lang, comp ay isang "malaking" signed integer na nagpapanatili ng 19..20 makabuluhang decimal digit. Kasabay nito, ang numeric data type comp sa mga expression ito ay ganap na katugma sa iba pang mga tunay na uri: ang lahat ng mga tunay na operasyon ay tinukoy dito, maaari itong magamit bilang isang argumento sa mga pag-andar ng matematika, atbp.

Tungkol sa pag-convert ng mga numeric na uri ng data ng Pascal

Sa Pascal, ang mga implicit (awtomatikong) conversion ng mga numeric na uri ng data ay halos imposible. Ang isang pagbubukod ay ginawa lamang para sa uri integer, na pinapayagang gamitin sa mga expression tulad ng totoo. Halimbawa, kung ang mga variable ay ipinahayag tulad nito:

Var X: integer; Y: totoo;

Yan ang operator

ay syntactically tama, bagama't mayroong isang integer expression sa kanan ng assignment sign at isang tunay na variable sa kaliwa, ang compiler ay awtomatikong magko-convert ng mga numeric data type. Ang reverse conversion ay awtomatikong uri totoo sa uri integer imposible sa Pascal. Tandaan natin kung gaano karaming mga byte ang inilalaan para sa mga variable ng uri integer At totoo: para sa integer na uri ng data integer 2 bytes ng memory ang inilalaan, at para sa tunay - 6 bytes. Upang mag-convert totoo V integer Mayroong dalawang built-in na function: bilog(x) iniikot ang totoong x sa pinakamalapit na integer, trunc(x) pinuputol ang isang tunay na numero sa pamamagitan ng pagtatapon ng fractional na bahagi.

Sinasaklaw ng aralin ang mga pangunahing karaniwang uri ng data sa Pascal, ang konsepto ng isang variable at isang pare-pareho; nagpapaliwanag kung paano gumana sa mga pagpapatakbo ng arithmetic

Ang Pascal ay isang typed programming language. Nangangahulugan ito na ang mga variable na nag-iimbak ng data ay may partikular na uri ng data. Yung. Dapat direktang ipahiwatig ng program kung anong data ang maaaring maimbak sa isang partikular na variable: data ng teksto, data ng numero, kung numeric, pagkatapos ay integer o fractional, atbp. Ito ay kinakailangan lalo na upang ang computer ay "alam" kung anong mga operasyon ang maaaring gawin sa mga variable na ito at kung paano gawin ang mga ito nang tama.

Halimbawa, ang pagdaragdag ng data ng teksto, o bilang ito ay tama na tinatawag sa programming - concatenation - ay ang karaniwang pagsasama ng mga string, habang ang pagdaragdag ng numeric data ay nangyayari nang bitwise, bilang karagdagan, ang mga fractional at integer na mga numero ay idinagdag din nang iba. Ang parehong naaangkop sa iba pang mga operasyon.

Tingnan natin ang pinakakaraniwang uri ng data sa Pascal.

Mga uri ng data ng integer sa Pascal

Uri	Saklaw	Kinakailangang memorya (bytes)
byte	0..255	1
shortint	-128..127	1
integer	-32768.. 32767	2
salita	0..65535	2
matagal	-2147483648..2147483647	4

Kailangan mong tandaan na kapag nagsusulat ng mga programa sa Pascal integer(isinalin mula sa Ingles sa kabuuan) ay ang pinakamadalas na ginagamit, dahil ang hanay ng mga halaga ay higit na hinihiling. Kung kailangan ng mas malawak na hanay, gamitin matagal(mahabang integer, isinalin mula sa Ingles bilang long integer). Uri byte sa Pascal ito ay ginagamit kapag hindi na kailangang magtrabaho sa mga negatibong halaga, ang parehong napupunta para sa uri salita(tanging ang hanay ng mga halaga dito ay mas malaki).

Mga halimbawa kung paano inilarawan ang mga variable (ipinahayag) sa Pascal:

programa a1; var x,y:integer; (uri ng integer) myname:string; (uri ng string) simulan ang x:=1; y:=x+16; myname:="Peter"; writeln("pangalan: ",myname, ", edad: ", y) dulo.

Resulta:
pangalan: Pedro, edad: 17

Mga komento sa Pascal

Pansinin kung paano ang mga komento ay ginagamit sa Pascal. Sa mga halimbawang komento, i.e. Ang text ng serbisyo na "hindi nakikita" ng compiler ay nakapaloob sa mga kulot na brace. Karaniwan, ang mga komento ay ginawa ng mga programmer upang ipaliwanag ang mga piraso ng code.

Gawain 3. Ang populasyon ng Moscow ay isang = 9,000,000 na naninirahan. Ang populasyon ng New Vasyuki ay b=1000 na naninirahan. Sumulat ng isang programa na tumutukoy sa pagkakaiba sa bilang ng mga naninirahan sa pagitan ng dalawang lungsod. Gumamit ng mga Variable

Mga totoong uri ng data sa Pascal

Ang mga tunay na numero sa Pascal at sa programming sa pangkalahatan ay ang pangalan para sa mga fractional na numero.

Uri	Saklaw	Kinakailangang memorya (bytes)
totoo	2.9 * 10E-39 .. 1.7 * 10E38	6
walang asawa	1.5 * 10 E-45 .. 3.4 * 10E38	4
doble	5 * 10E-324 .. 1.7 * 10E308	8
pinahaba	1.9 * 10E-4951 .. 1.1 * 10E4932	10

Ang tunay na uri sa Pascal ay ang pinakakaraniwang ginagamit na tunay na uri.

Iniharap ang nasa itaas mga simpleng uri ng data sa Pascal, na kinabibilangan ng:

• Ordinal
• buo
• Lohikal
• karakter
• Nakalista
• Pagitan
• totoo

Upang ipakita ang mga halaga ng mga variable ng totoong uri, karaniwang ginagamit ang naka-format na output:

ang format ay gumagamit ng alinman sa isang numero, na nagsasaad ng bilang ng mga posisyong nakalaan sa numerong ito sa exponential form;

p:=1234.6789; Writeln(p:6:2); (1234.68)

Kasama ng mga simpleng uri, ginagamit din ng wika mga structured na uri ng data at pointer, na magiging paksa ng mga susunod na aralin sa Pascal.

Mga Constant sa Pascal

Kadalasan sa isang programa ay alam nang maaga na ang isang variable ay kukuha ng isang tiyak na halaga at hindi ito babaguhin sa buong pagpapatupad ng buong programa. Sa kasong ito, dapat kang gumamit ng isang pare-pareho.

Ang deklarasyon ng isang pare-pareho sa Pascal ay nangyayari bago ang deklarasyon ng mga variable (bago ang var service word) at ganito ang hitsura:

Isang halimbawa ng palaging paglalarawan sa Pascal:

1 2 3 4 5 6

const x= 17 ;

var myname: string ;

begin myname: = "Peter" ;

writeln("pangalan: ", pangalan ko, ", edad: ", x) dulo.

const x=17; var myname:string; simulan ang aking pangalan:="Peter"; writeln("pangalan: ",myname, ", edad: ", x) end.

"Magandang" output ng mga integer at totoong numero

1. Upang matiyak na pagkatapos ipakita ang mga halaga ng mga variable ay mayroong mga indent, upang ang mga halaga ay hindi "magsama" sa isa't isa, kaugalian na ipahiwatig sa pamamagitan ng isang colon kung gaano karaming mga character ang kailangang ibigay upang ipakita ang halaga:
2. Mga operasyon sa aritmetika sa Pascal
3. Pagkakasunud-sunod ng mga operasyon

pagsusuri ng mga expression sa panaklong;

multiplikasyon, paghahati, div, mod mula kaliwa hanggang kanan;

• Ang inc operation sa Pascal, binibigkas na increment, ay isang karaniwang pamamaraan ng Pascal na nangangahulugan ng pagtaas ng isa.

Halimbawa ng operasyon ng inc:

x:=1; inc(x); (Tinataasan ang x ng 1, ibig sabihin, x=2) writeln(x)

Mas kumplikadong paggamit ng inc procedure:
Inc(x,n) kung saan ang x ay isang ordinal na uri, n ay isang integer na uri; procedure increments x by n.

• Ang pamamaraan ng Disyembre sa Pascal ay gumagana nang katulad: Dec(x) - binabawasan ang x ng 1 (decrement) o Dec(x,n) - binabawasan ang x ng n.
• Ang abs operator ay kumakatawan sa modulus ng isang numero. Ito ay gumagana tulad nito:

a: =- 9;

b:=abs(a);

• (b=9)
• a:=-9; b:=abs(a); (b=9)
• Ang div operator sa Pascal ay madalas na ginagamit, dahil ang isang bilang ng mga gawain ay kinabibilangan ng pagpapatakbo ng buong dibisyon.

Ang natitirang bahagi ng dibisyon o ang mod operator sa Pascal ay kailangan din para sa paglutas ng maraming problema.

Kapansin-pansin ang karaniwang odd function ng Pascal, na tumutukoy kung kakaiba ang isang integer. Ibig sabihin, nagbabalik ito ng true para sa mga kakaibang numero, mali para sa even na mga numero.

• Isang halimbawa ng paggamit ng kakaibang function: var x:integer; simulan ang x:=3; writeln(sqr(x)); (sagot 9) wakas.

Exponentiation operation sa Pascal

ay nawawala tulad nito. Ngunit upang mapataas ang isang numero sa isang kapangyarihan, maaari mong gamitin ang exp function.

Ang formula ay: exp(ln(a)*n), kung saan ang a ay isang numero, n ay isang degree (a>0).

Gayunpaman, sa Pascal abc compiler, ang exponentiation ay mas simple: var x:integer; simulan ang x:=9; writeln(sqrt(x)); (sagot 3) wakas.
Gawain 4.

Ang mga sukat ng isang kahon ng posporo ay kilala: taas - 12.41 cm, lapad - 8 cm, kapal - 5 cm Kalkulahin ang lugar ng base ng kahon at dami nito(S=lapad*kapal, V=lugar*taas)

Gawain 5. Ang zoo ay may tatlong elepante at medyo ilang mga kuneho, na ang bilang ng mga kuneho ay madalas na nagbabago. Ang isang elepante ay dapat kumain ng isang daang karot sa isang araw, at isang kuneho - dalawa. Tuwing umaga, sinasabi ng zookeeper sa computer ang bilang ng mga kuneho. Ang computer, bilang tugon dito, ay dapat sabihin sa attendant ang kabuuang bilang ng mga karot na kailangang ipakain sa mga kuneho at elepante ngayon. Gawain 6. Ito ay kilala na x kilo ng matamis na halaga a rubles Tukuyin kung magkano ang halaga nito y kg ng mga matatamis na ito, at gayundin kung ilang kilo ng matamis ang mabibili sa

k

rubles Ang lahat ng mga halaga ay ipinasok ng gumagamit.

• 3.2. Mga simpleng uri ng data sa Turbo Pascal 7
• Ang isang simpleng uri ay tumutukoy sa isang nakaayos na hanay ng mga halaga ng parameter. Ang Turbo Pascal ay may mga sumusunod na grupo ng mga simpleng uri:
• mga uri ng integer;
• uri ng boolean;
• uri ng karakter;
• enumerated type;

Ang lahat ng mga simpleng uri, maliban sa mga tunay na uri, ay tinatawag na mga uri ng ordinal. Para sa dami ng mga uri ng ordinal, ang mga karaniwang pamamaraan at paggana ay tinukoy: Dis, Inc, Ord, Pred, Succ (tingnan ang seksyon 13.1).

3.2.1. Mga uri ng integer

Hindi tulad ng Pascal, na tumutukoy sa isang solong uri ng integer, Integer, ang Turbo Pascal ay may limang karaniwang uri ng integer: Shortint, Integer, Longint, Byte, Word. Ang mga katangian ng mga uri na ito ay ibinibigay sa talahanayan. 2.

Talahanayan 2. Integer na mga uri ng data

Uri	Saklaw	Format	Sukat sa bytes
Shortint	-128 .. 127	iconic	1
Integer	-32768 .. 32767	iconic	2
Longint	-2147483648 .. 2147483647	iconic	4
Byte	0 .. 255	Hindi nakapirma	1
salita	0 .. 65535	Hindi nakapirma	2

3.2.2. Uri ng Boolean

Ang karaniwang uri ng Boolean (laki - 1 byte) ay isang uri ng data, anumang elemento na maaaring tumagal lamang ng dalawang halaga: True at False. Sa kasong ito, ang mga sumusunod na kondisyon ay wasto:
False Ord (False) = 0
Ord (Totoo) = 1
Succ (Mali) = Tama
Pred (True) = Mali

Nagdagdag ang Turbo Pascal 7.0 ng tatlo pang lohikal na uri na ByteBool (laki - 1 byte), WordBool (laki - 2 byte) at LongBool (laki - 4 byte). Ipinakilala sila para sa pag-iisa sa iba pang mga programming language at sa kapaligiran ng Windows. Ang kanilang pagkakaiba mula sa karaniwang uri ng Boolean ay ang aktwal na halaga ng parameter ng ganitong uri, na tumutugma sa halagang True. Para sa lahat ng lohikal na uri, ang value na False ay tumutugma sa numero 0, na nakasulat sa kaukulang bilang ng mga byte. Ang value na True para sa Boolean type ay tumutugma sa numero 1 na nakasulat sa byte nito, at para sa iba pang mga uri ang value na True ay tumutugma sa anumang numero maliban sa zero (bagaman ang Ord function sa kasong ito ay nagbibigay ng value 1).

3.2.3. Uri ng karakter

Ang karaniwang uri ng character na Char ay tumutukoy sa isang buong hanay ng mga ASCII na character. Ang Ord function mula sa isang halaga ng uri ng Char ay nagbibigay ng code ng kaukulang karakter. Ang mga halaga ng uri ng character ay inihambing ayon sa kanilang mga code.

3.2.4. Uri ng enum

Ang isang enumerated na uri ay hindi karaniwan at tinutukoy ng isang hanay ng mga identifier na maaaring tumugma sa mga value ng parameter. Ang listahan ng mga identifier ay ipinahiwatig sa mga panaklong, ang mga identifier ay pinaghihiwalay ng mga kuwit:

uri
= ();)

Mahalaga sa kung anong pagkakasunud-sunod ang mga identifier ay nakalista kapag tinutukoy ang isang uri, dahil ang unang identifier ay itinalaga ang serial number 0, ang pangalawa - 1, atbp. Ang parehong identifier ay maaaring gamitin sa kahulugan ng isang enumerated type lamang. Ang function ng Ord mula sa isang halaga ng isang enumerated na uri ay nagbibigay ng ordinal na numero ng halaga nito.

Halimbawa. Enumerated type.

uri ng Operat = (Plus, Minus, Mult, Divide);

Ang isang boolean na uri ay isang espesyal na kaso ng isang enumerated na uri:

i-type ang Boolean = (Mali, Tama);

3.2.5. Uri-range

Sa anumang uri ng ordinal, maaari kang pumili ng subset ng mga halaga, na tinukoy ng pinakamababa at maximum na mga halaga, na kinabibilangan ng lahat ng mga halaga ng orihinal na uri na nasa loob ng mga hangganang ito, kabilang ang mga hangganan mismo. Tinutukoy ng subset na ito ang isang uri ng hanay. Tinukoy ang uri ng hanay sa pamamagitan ng pagtukoy sa minimum at maximum na mga halaga, na pinaghihiwalay ng dalawang tuldok:

uri = . . ;

Ang pinakamababang halaga kapag tinutukoy ang ganitong uri ay hindi dapat mas malaki kaysa sa maximum.

Halimbawa. Kahulugan ng mga uri ng saklaw.

uri
Dosenang = 1..12; (mga numero mula 1 hanggang 12)
AddSub = Plus..Minus; (mga pagpapatakbo ng pagdaragdag at pagbabawas)

3.2.6. Mga totoong tipo

Hindi tulad ng pamantayan ng wikang Pascal, kung saan isang tunay na uri lamang ang tinutukoy na Real, ang Turbo Pascal ay may limang karaniwang mga tunay na uri: Real, Single, Double, Extended, Comp. Para sa mga katangian ng mga ganitong uri, tingnan ang talahanayan. 3. Talahanayan 3. Mga totoong uri ng data

Uri	Saklaw	Bilang ng mga makabuluhang numero	Sukat sa bytes
totoo	2.9*10-39..1.7*1038	11-12	6
Walang asawa	1.5*10-45..3.4*1038	7-8	4
Doble	5.0*10-324.-1.7*10308	15-16	8
Extended	3.4*10-4932..1.1*104932	19-20	10
Comp	-263+1..263-1	19-20	8

Ang uri ng Comp ay talagang isang pinahabang uri ng integer na hanay, ngunit hindi itinuturing na isang uri ng ordinal.

Ang mga uri ng Single, Double, Extended at Comp ay magagamit lamang sa mga programa kung mayroong arithmetic coprocessor o kapag pinagana ang coprocessor emulator (tingnan ang mga talata 17.5.8 at 17.7.1).

LECTURE 2

Mga pangunahing kaalaman sa programming.

Panimula kay Pascal. Mga uri ng data. Mga operasyon.

Alpabeto ng wikaPascal

Ang anumang natural na wika ay binubuo ng mga elemento tulad ng mga simbolo, salita, parirala, at pangungusap. Ang isang programming language ay mayroon ding mga katulad na elemento: mga simbolo, salita, expression (mga parirala), operator (mga pangungusap).

Ang mga salita ay nabuo mula sa isang koleksyon ng mga simbolo. Mga ekspresyon - ito ay mga grupo ng mga salita, at mga operator - Ito ay mga kumbinasyon ng mga salita at ekspresyon. Ang mga simbolo ng wika ay mga elementarya na palatandaan (titik) na ginagamit sa pagbuo ng ilang teksto. Kaya, ang hanay ng mga simbolong ito ay bumubuo sa alpabeto ng wika.

Ang alpabetong Pascal ay binubuo ng:

1.malaki at maliit na titik ng alpabetong Latin, na kinabibilangan ng mga sumusunod na character:

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z - malalaking titik;

A b c d e f g h i j k l m n o p q r s t u v w x y z - maliliit na titik;

2. decimal Arabic numeral: 0 1 2 3 4 5 6 7 8 9;

3. hexadecimal digit (binuo mula sa decimal digit at letra mula A hanggang F);

4. 32 malaki at maliit na titik ng alpabetong Ruso;

5. mga espesyal na karakter:

Ang mga kumbinasyon ng mga espesyal na character ay maaaring bumuo ng mga tambalang character:

: = takdang-aralin;

< >hindi pantay;

>= mas malaki sa o katumbas ng;

<= меньше или равно;

Saklaw ng mga halaga;

(* *) o ( ) - komento.

Istraktura ng programa ng Pascal

Upang ang Passal compiler ay maunawaan nang tama kung ano ang mga aksyon na inaasahan dito, ang iyong programa ay dapat na idinisenyo nang buong alinsunod sa syntax (mga tuntunin ng pagbuo ng programa) ng wikang ito.

Ang anumang programa ng Pascal ay maaaring binubuo ng mga sumusunod na bloke (mga opsyonal na bahagi ay minarkahan ng mga square bracket pagkatapos nito):

programa<имя_программы>;

[ginagamit<имена_подключаемых_модулей>;]

[ label<список_меток>;]

[ const<имя_константы> = <значение_константы>;]

[ uri<имя_типа> = <определение_типа>;]

[var<имя_переменной> : <тип_переменной>;]

[ pamamaraan<имя_процедуры> <описание_процедуры>;]

[ function<имя_функции> <описание_функции>;]

magsimula (simula ng pangunahing katawan ng programa)

<операторы>

wakas. (* dulo ng pangunahing katawan ng programa *)

Ang mga susunod na bersyon ng mga compiler ng wikang Pascal ay hindi na nangangailangan ng pagtukoy sa pangalan ng programa, iyon ay, ang linya ng programa<имя_программы>; maaaring tanggalin. Ngunit ito ay posible lamang kung ang buong programa ay nakapaloob sa isang module file. Kung ang programa ay binubuo ng ilang mga independiyenteng piraso - mga module, kung gayon ang bawat isa sa kanila ay dapat magkaroon ng isang header (program o yunit).

Ang alinman sa mga nakalistang opsyonal na seksyon ay maaaring lumitaw sa teksto ng programa nang higit sa isang beses, ang kanilang pangkalahatang pagkakasunud-sunod ay maaari ding magbago, ngunit ang pangunahing tuntunin ng wikang Pascal ay dapat palaging sundin: bago gamitin ang isang bagay, dapat itong ipahayag at ilarawan.

Ang mga compiler ng Pascal ay hindi nakikilala sa pagitan ng maliliit at malalaking titik at binabalewala ang mga character na whitespace, kaya ang teksto ng programa ay maaaring isaayos sa paraang gawin itong pinaka maginhawang basahin at i-debug.

Mga direktiba ng compiler

Ang linya na nagsisimula sa mga simbolo ($ ay hindi isang komento, ngunit isang direktiba ng compiler - isang espesyal na utos kung saan nakasalalay ang proseso ng pagsasama-sama at pagpapatupad ng programa. Isasaalang-alang namin ang mga direktiba sa mga seksyong iyon kung saan nauugnay ang mga ito "sa kahulugan".

Halimbawa, ang linya ($I-,Q+) ay hindi pinapagana ang I/O validation ngunit pinapagana ang computation overflow control.

Mga identifier

Ang mga pangalan na ibinigay sa mga bagay ng programa (constant, uri, variable, function at procedure, at ang buong program) ay tinatawag na mga identifier. Maaari lamang silang binubuo ng mga numero, mga letrang Latin at ang "_" (underscore) sign. Gayunpaman, ang isang numero ay hindi maaaring magsimula ng isang pangalan. Ang mga identifier ay maaaring maging anumang haba, ngunit kung ang dalawang pangalan ay may parehong unang 63 character, ang mga pangalan ay itinuturing na magkapareho.

Maaari mong bigyan ng anumang pangalan ang mga object ng iyong program, ngunit dapat mong tiyakin na iba ang mga ito sa mga nakareserbang salita na ginamit ni Pascal, dahil hindi pa rin tatanggap ang compiler ng mga variable na may mga "banyagang" pangalan.

Narito ang isang listahan ng mga pinakakaraniwang nakalaan na salita:

pagpapatupad ng array shl

string ng interface ng kaso

const label noon

ginagamit ng file pointer

malayong pamamaraan var

para sa programa habang

forward record na may

function ulitin xor

Mga variable at uri ng data

Ang variable ay isang object ng program na maaaring magbago ang value habang tumatakbo ang program.

Ang uri ng data ay isang katangian ng hanay ng mga halaga na maaaring kunin ng mga variable na kabilang sa uri ng data na iyon.

Ang lahat ng mga variable na ginamit sa programa ay dapat na inilarawan sa isang espesyal na seksyon ng var gamit ang sumusunod na template:

var<имя_переменной_1> [, <имя_переменной_2, _>] : <имя_типа_1>;

<имя_переменной_3> [, <имя_переменной_4, _>] : <имя_типа_2>;

Ang wikang Pascal ay may malaking hanay ng iba't ibang uri ng data, ngunit ngayon ay iilan lamang sa mga ito ang ipapahiwatig namin. Pag-uusapan pa natin ang lahat ng uri ng data.

Mga Constant

Ang isang pare-pareho ay isang bagay na ang halaga ay kilala bago magsimulang tumakbo ang programa.

Ang mga constant ay kinakailangan para sa disenyo ng mga visual na programa, ay kailangang-kailangan kapag gumagamit ng paulit-ulit na paulit-ulit na mga halaga sa teksto ng isang programa, at maginhawa kung kinakailangan upang baguhin ang mga halagang ito sa buong programa nang sabay-sabay.

Mayroong tatlong uri ng mga constant sa Pascal:

Mga hindi pinangalanang constant (mga digit at numero, simbolo at string, set);

Pinangalanang untyped constants;

Pinangalanang mga na-type na constant.

Mga Constant na Walang Pangalan

Ang mga hindi pinangalanang constant ay walang mga pangalan at samakatuwid ay hindi kailangang ideklara.

Awtomatikong natutukoy ang uri ng hindi pinangalanang constant, bilang default:

Anumang pagkakasunud-sunod ng mga numero (marahil ay pinangungunahan ng isang "-" o "+" na senyales, o pinaghiwa-hiwalay ng isang solong tuldok) ay itinuturing ng compiler bilang isang walang pangalan na pare-pareho - isang numero (integer o tunay);

Anumang pagkakasunod-sunod ng mga character na nakapaloob sa mga kudlit ay itinuturing bilang isang hindi pinangalanang constant - isang string;

Anumang pagkakasunud-sunod ng mga integer o simbolo na pinaghihiwalay ng mga kuwit, na naka-frame sa pamamagitan ng mga square bracket, ay itinuturing bilang isang hindi pinangalanang constant - isang set.

Bilang karagdagan, mayroong dalawang espesyal na constant na totoo at mali na nauugnay sa uri ng data ng Boolean.

Kasama sa mga halimbawa ng paggamit ng mga hindi pinangalanang constant ang mga sumusunod na operator:

real2:= 12.075 + x;

string4: = "abc" + string44;

set5:= * set55;

boolean6:= totoo;

Mga Hindi Na-type na Constant

Ang pinangalanang mga constant, gaya ng iminumungkahi ng kanilang pangalan, ay dapat magkaroon ng pangalan. Samakatuwid, ang mga pangalang ito ay dapat iulat sa compiler, iyon ay, inilarawan sa isang espesyal na seksyon ng const.

Kung hindi mo tinukoy ang uri ng isang pare-pareho, pagkatapos ay sa pamamagitan ng hitsura nito ang compiler mismo ay matukoy kung aling (base) na uri ito dapat italaga. Maaaring gamitin ang anumang pare-parehong inilarawan na kapag nagdedeklara ng iba pang mga constant, variable at uri ng data. Narito ang ilang halimbawa ng paglalarawan ng mga hindi na-type na pinangalanang constant:

Mga na-type na Constant

Ang mga na-type na pinangalanang constant ay mga variable(!) na may paunang halaga na alam na sa oras na magsimula ang programa. Samakatuwid, una, ang mga na-type na constant ay hindi maaaring gamitin upang tukuyin ang iba pang mga constant, mga uri ng data at mga variable, at pangalawa, ang kanilang mga halaga ay maaaring mabago habang tumatakbo ang programa.

Ang mga nai-type na constant ay inilalarawan gamit ang sumusunod na template:

const<имя_константы> : <тип_константы> = <начальное_значение>;

Ipinapakita ng mga halimbawa sa ibaba kung paano ito gawin:

const n: integer = -10;

b: boolean = totoo;

Magbibigay kami ng mga halimbawa ng mga na-type na constant ng iba pang mga uri habang pinag-aaralan namin ang mga kaukulang uri ng data.

Mga uri ng data ng Pascal

Ang mga compiler ng Pascal ay nangangailangan na ang impormasyon tungkol sa dami ng memorya na kinakailangan upang magpatakbo ng isang programa ay ibigay bago ito tumakbo. Upang gawin ito, sa seksyon ng paglalarawan ng variable (var), kailangan mong ilista ang lahat ng mga variable na ginamit sa programa. Bilang karagdagan, kailangan mo ring sabihin sa compiler kung gaano karaming memorya ang sasakupin ng bawat isa sa mga variable na ito.

Ang lahat ng ito ay maaaring ipaalam sa programa sa pamamagitan lamang ng pagpahiwatig ng uri ng hinaharap na variable. Ang pagkakaroon ng impormasyon tungkol sa uri ng isang variable, ang compiler ay "naiintindihan" kung gaano karaming mga byte ang kailangang ilaan para dito, kung anong mga aksyon ang maaaring isagawa kasama nito, at sa kung anong mga konstruksyon ang maaari itong lumahok.

Para sa kaginhawahan ng mga programmer, ang Pascal ay may maraming karaniwang mga uri ng data at, bilang karagdagan, ang kakayahang lumikha ng mga bagong uri ng data batay sa mga umiiral na (standard o muling tinukoy ng programmer), na tinatawag na constructed.

Ang paghahati sa basic at constructed na mga uri ng data sa Pascal ay ipinapakita sa talahanayan:

	Ordinal (discrete) na mga uri ng data				Mga uri ng data ng address	Mga Uri ng Structured Data
			Mga uri ng data ng aritmetika
Pangunahing Uri ng Data	Lohikal	Simboliko		totoo	Netipizi na-index na index
Mga uri ng binuo	Nakalista linggo = (su, mo, tu, kami, ika, fr,sa);				Nag-type ng pointer	Array String string record record Pamamaraan Bagay
	Interval (saklaw)
	Mga Uri ng Data na Binuo ng Programmer

Mga uri ng ordinal na data

Kabilang sa mga pangunahing uri ng data, namumukod-tangi ang mga uri ng ordinal. Maaaring bigyang-katwiran ang pangalang ito sa dalawang paraan:

1. Ang bawat elemento ng isang uri ng ordinal ay maaaring iugnay sa isang natatanging (ordinal) na numero. Ang pagbilang ng mga halaga ay nagsisimula sa zero. Ang exception ay ang shortint, integer at longint na mga uri ng data. Ang kanilang pag-numero ay tumutugma sa mga halaga ng mga elemento.

2. Bilang karagdagan, sa mga elemento ng anumang uri ng ordinal, ang isang pagkakasunud-sunod ay tinukoy (sa matematikal na kahulugan ng salita), na direktang nakasalalay sa pagnunumero. Kaya, para sa alinmang dalawang elemento ng isang uri ng ordinal, masasabi nang eksakto kung alin sa mga ito ang mas maliit at alin ang mas malaki.

Mga karaniwang gawain na humahawak sa mga uri ng ordinal na data

Ang mga sumusunod na function at pamamaraan ay tinukoy lamang para sa mga uri ng ordinal:

1. Ang ord(x) function ay nagbabalik ng ordinal na numero ng halaga ng variable na x (na may kaugnayan sa uri kung saan nabibilang ang variable na x).

2.Ibinabalik ng function na pred(x) ang value na sinusundan ng x (hindi naaangkop sa unang elemento ng uri).

3. Ibinabalik ng function na succ(x) ang value kasunod ng x (hindi naaangkop sa huling elemento ng uri).

4. Ibinabalik ng procedure inc(x) ang value kasunod ng x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x+1).

5. Ibinabalik ng procedure inc(x,k) ang kth value kasunod ng x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x+k).

6. Ibinabalik ng procedure dec(x) ang value na nauuna sa x (para sa mga uri ng data ng arithmetic ito ay katumbas ng operator x:=x-1).

7. Ibinabalik ng procedure dec(x,k) ang k-e value na nauuna sa x (para sa mga arithmetic data type na ito ay katumbas ng operator x:=x-k).

Sa unang tingin, lumalabas na ang resulta ng paggamit ng inc(x) procedure ay eksaktong kapareho ng resulta ng paggamit ng succ(x) function. Gayunpaman, lumilitaw ang pagkakaiba sa pagitan ng mga ito sa mga hangganan ng pinapayagang hanay. Ang succ(x) function ay hindi naaangkop sa maximum na elemento ng isang uri, ngunit ang inc(x) na pamamaraan ay hindi gagawa ng anumang error, ngunit, sa pagkilos ayon sa mga patakaran ng machine karagdagan, ay idaragdag ang susunod na unit sa element number . Ang numero, siyempre, ay lalampas sa hanay at, dahil sa pagputol, ay magiging bilang ng pinakamababang halaga ng hanay. Lumalabas na ang mga pamamaraan inc() at dec() ay nakikita ang anumang uri ng ordinal na parang "nakasara sa isang singsing": kaagad pagkatapos ng huling halaga ay dumating muli ang unang halaga.

Ipaliwanag natin ang lahat ng nasabi nang may halimbawa. Para sa uri ng data

uri ng labing-anim = 0..15;

Ang pagsubok na magdagdag ng 1 sa numerong 15 ay magbibigay ng sumusunod na resulta:

Ang paunang yunit ay puputulin, at samakatuwid ay lumalabas na inc(15)=0.

Ang isang katulad na sitwasyon sa mas mababang limitasyon ng pinahihintulutang hanay ng isang arbitrary na ordinal na uri ng data ay sinusunod para sa pamamaraan dec(x) at ang function na pred(x):

dec(min_element)= max_element

Mga uri ng data na nauugnay sa ordinal

1. Ang boolean type ay may dalawang value: false at true, at ang mga sumusunod na equalities ay may hawak para sa kanila:

ord(false)=0, ord(true)=1, false

pred(true)=false, succ(false)=true,

inc(true)=false, inc(false)=true,

dec(true)=false, dec(false)=true.

2. Ang uri ng character na char ay naglalaman ng 256 pinahabang ASCII character (halimbawa, "a", "b", "i", "7", "#"). Ang numero ng character na ibinalik ng ord() function ay kapareho ng numero ng character sa talahanayan ng ASCII.

3. Ibuod natin ang mga uri ng data ng integer sa isang talahanayan:

Uri ng data	Bilang ng mga byte	Saklaw
		2147483648..2147483647

4. Ang mga enumerated na uri ng data ay tinukoy sa seksyon ng uri sa pamamagitan ng tahasang paglilista ng mga elemento ng mga ito. Halimbawa:

uri ng linggo =(araw,mon,Martes,wed,thu,fri,sat)

Tandaan na para sa uri ng data na ito:

inc(sat) = araw, dec(sun) = sat.

5. Ang mga uri ng data ng pagitan ay tinutukoy lamang ng mga hangganan ng kanilang hanay. Halimbawa:

uri ng buwan = 1..12;

budni = mon..fri;

6. Ang mga uri ng data na binuo ng programmer ay inilarawan sa seksyon ng uri ayon sa sumusunod na pattern:

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

Halimbawa:

type lat_bukvy = "a".."z","A".."Z";

Ang mga pangunahing uri ng data ay karaniwan, kaya hindi na kailangang ilarawan ang mga ito sa seksyon ng uri. Gayunpaman, kung ninanais, maaari rin itong gawin, halimbawa, sa pamamagitan ng pagbibigay ng mahahabang kahulugan ng mga maikling pangalan. Sabihin natin sa pamamagitan ng pagpapakilala ng bagong uri ng data

uri int = integer;

Maaari mong paikliin ng kaunti ang teksto ng programa.

Mga totoong uri ng data

Alalahanin na ang mga uri ng data na ito ay arithmetic, hindi ordinal.

Uri ng data	Bilang ng mga byte	Saklaw (ganap na halaga)
		1.5*10-45..3.4*1038
		2.9*10-39..1.7*1038
		5.0*10-324..1.7*10308
		3.4*10-4932..1.1*104932

Mga uri ng data na binuo

Isasaalang-alang namin ang mga uri ng data na ito (kasama ang mga pagpapatakbo na tinukoy para sa kanila) nang higit pa sa kurso ng ilang mga lektura.

Mga Operasyon at Ekspresyon

Mga operasyon sa aritmetika

Pag-usapan natin ang tungkol sa mga pagpapatakbo - karaniwang mga pagkilos na pinapayagan para sa mga variable ng isa o isa pang pangunahing uri ng data. Ang magiging batayan ay arithmetic at logical operations.

Tandaan: Ang lahat ng mga operator na nakalista sa ibaba (maliban sa unary "-" at hindi) ay nangangailangan ng dalawang operand.

1. Ang mga lohikal na operasyon (at - lohikal AT, o - lohikal O, hindi - lohikal na HINDI, xor - eksklusibo O) ay naaangkop lamang sa mga halaga ng uri ng boolean. Nagreresulta rin ang mga ito sa mga boolean na halaga. Narito ang mga talahanayan ng mga halaga para sa mga operasyong ito:

		totoo mali totoo maling mali mali	totoo mali mali

2. Mga operasyon sa paghahambing (=,<>, >, <, <=, >=) nalalapat sa lahat ng pangunahing uri. Ang kanilang mga resulta ay mga boolean value din.

3. Ang mga pagpapatakbo ng integer arithmetic ay naaangkop lamang sa mga uri ng integer. Ang kanilang resulta ay isang integer na ang uri ay nakasalalay sa mga uri ng mga operand.

a div b - ganap na paghahati ng a sa b (marahil hindi na kailangang ipaalala sa iyo na ipinagbabawal ang paghahati sa 0, kaya sa mga ganitong kaso ang operasyon ay bumubuo ng isang error). Ang resulta ay isang uri ng data na karaniwan sa mga uri kung saan nabibilang ang mga operand.

Halimbawa, (shortint div byte = integer). Ito ay maaaring ipaliwanag sa ganitong paraan: ang integer ay isang minimal na uri kung saan ang parehong byte at shortint ay mga subset.

a mod b - kunin ang natitira kapag hinahati ang a sa b. Ang uri ng resulta, tulad ng sa nakaraang kaso, ay tinutukoy ng mga uri ng mga operand, at ang 0 ay isang ilegal na halaga para sa b. Hindi tulad ng mathematical operation mod, ang resulta nito ay palaging isang di-negatibong numero, ang tanda ng resulta ng "programmer" operation mod ay tinutukoy ng sign ng unang operand nito. Kaya, kung sa matematika (-2 mod 5) = 3, mayroon tayong (-2 mod 5) = -2.

a shl k - ilipat ang halaga ng a by k bits sa kaliwa (ito ay katumbas ng pagpaparami ng halaga ng variable a ng 2k). Ang resulta ng operasyon ay magiging kapareho ng uri ng (mga) unang operand nito.

a shr k - inililipat ang halaga ng a by k bits sa kanan (ito ay katumbas ng paghahati ng halaga ng variable a ng 2k nang buo). Ang resulta ng operasyon ay magiging kapareho ng uri ng (mga) unang operand nito.

at, o, hindi, xor - binary arithmetic operations na gumagana sa mga bits ng binary representation ng integers, ayon sa parehong mga panuntunan tulad ng kaukulang logical operations.

4. Ang mga pangkalahatang pagpapatakbo ng arithmetic (+, -, *, /) ay nalalapat sa lahat ng uri ng arithmetic. Ang kanilang resulta ay nabibilang sa isang uri ng data na karaniwan sa parehong mga operand (ang tanging pagbubukod ay ang fractional division operation /, ang resulta nito ay palaging isang tunay na uri ng data).

Iba pang mga operasyon

Mayroong iba pang mga operasyon na tiyak sa mga halaga ng ilan sa mga karaniwang uri ng data ng Pascal. Isasaalang-alang namin ang mga operasyong ito sa naaangkop na mga seksyon:

#, in, +, *, : tingnan ang lecture 5 “Mga Simbolo. Mga linya. maraming tao"

@, ^: tingnan ang lecture 7 "Mga Address at pointer"

Mga karaniwang function ng arithmetic

Kasama rin sa mga operasyon ng aritmetika ang mga karaniwang function ng arithmetic. Nagbibigay kami ng isang listahan ng mga ito na may maikling paglalarawan sa talahanayan.

Function	Paglalarawan	Uri ng argumento	Uri ng resulta
	Ganap na halaga (modulus) ng isang numero	Arithmetic	Pareho sa uri ng argumento
	Arctangent (sa radians)	Arithmetic	totoo
	Cosine (sa radians)	Arithmetic	totoo
	Exponent (hal)	Arithmetic	totoo
	Pagkuha ng fractional na bahagi ng isang numero	Arithmetic	totoo
	Kinukuha ang buong bahagi ng isang numero	Arithmetic	totoo
	Natural logarithm (base e)	Arithmetic	totoo
	Sinusuri kung ang isang numero ay kakaiba
	Kahulugan ng numero		totoo
	Bilugan sa pinakamalapit na integer	Arithmetic
	Pag-round down - sa pinakamalapit na mas maliit na integer	Arithmetic
	Sine (sa radians)	Arithmetic	totoo
	Pag-squaring	Arithmetic	totoo
	Square Root	Arithmetic	totoo

Arithmetic Expressions

Ang lahat ng mga pagpapatakbo ng aritmetika ay maaaring pagsamahin sa bawat isa - siyempre, isinasaalang-alang ang mga uri ng data na pinapayagan para sa kanilang mga operand.

Ang mga operand ng anumang operasyon ay maaaring mga variable, constants, function call, o expression na binuo batay sa iba pang mga operasyon. Ang lahat ng sama-sama ay tinatawag na isang ekspresyon.

Mga halimbawa ng mga expression na aritmetika:

(x<0) and (y>0) - isang expression na ang resulta ay uri ng boolean;

z shl abs(k) - ang pangalawang operand ay isang tawag sa karaniwang function;

(x mod k) + min(a,b) + trunc(z) - isang kumbinasyon ng mga arithmetic operations at function calls;

kakaiba(round(x/abs(x))) - "multi-story" expression.

Pagkakasunud-sunod ng pagkalkula

Kung ang expression ay naglalaman ng mga panaklong, kung gayon ang mga kalkulasyon ay isinasagawa sa sumusunod na pagkakasunud-sunod: mas maliit ang lalim ng nesting ng mga panaklong, mas huli ang operasyon na nakapaloob sa mga ito ay kinakalkula. Kung walang mga panaklong, kung gayon ang mga halaga ng mga operasyon na may mas mataas na priyoridad ay unang kinakalkula, pagkatapos ay ang mga may mas mababang priyoridad. Ang ilang magkakasunod na operasyon ng parehong priyoridad ay kinakalkula sa pagkakasunud-sunod mula kaliwa hanggang kanan.

Talahanayan 2.1. Mga Priyoridad (para sa lahat) mga pagpapatakbo ng Pascal

Ang isang uri ng data ay tumutukoy sa isang hanay ng mga wastong halaga at isang hanay ng mga wastong operasyon.

Mga simpleng uri.

Ang mga simpleng uri ay nahahati sa ORDINAL at TOTOO.

1. MGA URI NG ORDERAL , sa turn, mayroong:

a) buo

Tinukoy ni Pascal ang 5 uri ng integer, na tinukoy depende sa sign at value na kukunin ng variable.

I-type ang pangalan	Haba (sa bytes)	Saklaw ng mga halaga
		32 768...+32 767
		2 147 483 648...+2 147 483 647

b) lohikal

Ang pangalan ng ganitong uri ay BOOLEAN. Ang mga halaga ng Boolean ay maaaring isa sa mga lohikal na constants: TRUE (true) o FALSE (false).

c) simboliko

Ang pangalan ng ganitong uri ay CHAR - sumasakop ng 1 byte. Ang halaga ng isang uri ng character ay ang hanay ng lahat ng mga character sa PC. Ang bawat karakter ay bibigyan ng integer sa hanay na 0…255. Ang numerong ito ay nagsisilbing code para sa panloob na representasyon ng simbolo.

2. MGA TOTOONG URI .

Hindi tulad ng mga uri ng ordinal, na ang mga halaga ay palaging nakamapa sa isang serye ng mga integer at samakatuwid ay ganap na kinakatawan sa PC, ang mga halaga ng mga tunay na uri ay tumutukoy sa isang arbitrary na numero lamang na may ilang tiyak na katumpakan depende sa panloob na format ng tunay na numero. .

Haba ng numeric data type, bytes	Numeric na pangalan ng uri ng data	Bilang ng mga makabuluhang digit ng isang numeric na uri ng data	Desimal na hanay ng pagkakasunud-sunod ng isang numeric na uri ng data
			2*1063 +1..+2*1063 -1

STRUCTURED TYPES

Tinutukoy ng mga structured na uri ng data ang isang nakaayos na koleksyon ng mga scalar variable at nailalarawan sa pamamagitan ng uri ng kanilang mga bahagi.

Ang mga nakabalangkas na uri ng data, hindi tulad ng mga simple, ay tumutukoy sa maraming kumplikadong mga halaga na may isang karaniwang pangalan. Masasabi nating ang mga uri ng istruktura ay tumutukoy sa isang tiyak na paraan ng pagbuo ng mga bagong uri mula sa mga umiiral na.

Mayroong ilang mga paraan ng pag-istruktura. Ayon sa paraan ng organisasyon at uri ng mga bahagi sa mga kumplikadong uri ng data, ang mga sumusunod na uri ay nakikilala: regular na uri (mga array); pinagsamang uri (mga talaan); filetype(mga file); maramihang (mga) uri; uri ng string (mga string); sa wikang Turbo Pascal na bersyon 6.0 at mas luma, isang uri ng bagay (mga bagay) ang ipinakilala.

Hindi tulad ng mga simpleng uri ng data, ang structured na uri ng data ay nailalarawan sa pamamagitan ng maraming elemento na bumubuo sa ganitong uri, i.e. ang isang variable o pare-pareho ng isang structured na uri ay palaging may maraming mga bahagi. Ang bawat bahagi, sa turn, ay maaaring kabilang sa isang nakabalangkas na uri, i.e. Posible ang nesting ng mga uri.

1. Mga array

Ang mga array sa Turbo Pascal sa maraming paraan ay katulad ng mga katulad na uri ng data sa ibang mga programming language. Ang isang natatanging tampok ng mga array ay ang lahat ng kanilang mga bahagi ay data ng parehong uri (posibleng nakabalangkas). Ang mga bahaging ito ay madaling maisaayos at alinman sa mga ito ay maaaring ma-access sa pamamagitan lamang ng pagtukoy ng serial number.

Ang paglalarawan ng array ay tinukoy bilang mga sumusunod:

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

Dito<имя типа>- tamang identifier;

Array, ng – nakalaan na salita (array, from);

<сп.инд.типов>- isang listahan ng isa o higit pang mga uri ng index, na pinaghihiwalay ng mga kuwit; Ang mga square bracket na nag-frame ng listahan ay isang kinakailangan ng syntax;

<тип>- anumang uri ng Turbo Pascal.

Maaaring gamitin ang anumang uri ng ordinal bilang mga uri ng index sa Turbo Pascal, maliban sa LongInt at mga uri ng hanay na may baseng uri na LongInt.

Ang lalim ng nesting ng mga structured na uri sa pangkalahatan, at samakatuwid ng mga array, ay arbitrary, kaya ang bilang ng mga elemento sa listahan ng mga type index (laki ng array) ay hindi limitado, gayunpaman, ang kabuuang haba ng panloob na representasyon ng anumang array ay hindi maaaring maging higit sa 65520 bytes.

2. Mga tala

Ang talaan ay isang istraktura ng data na binubuo ng isang nakapirming bilang ng mga bahagi na tinatawag na mga field ng talaan. Hindi tulad ng isang array, ang mga bahagi (mga patlang) ng isang talaan ay maaaring may iba't ibang uri. Upang gawing posible na sumangguni sa isa o ibang bahagi ng isang talaan, pinangalanan ang mga patlang.

Ang istraktura ng isang deklarasyon ng uri ng post ay:

< Pangalanuri>= RECORD< joint venture. mga patlang>WAKAS

Dito<имя типа>- tamang identifier;

RECORD, END – mga nakalaan na salita (record, end);

<сп.полей>- listahan ng mga patlang; ay isang pagkakasunod-sunod ng mga seksyon ng isang talaan na pinaghihiwalay ng isang tuldok-kuwit.

3. Mga set

Ang mga set ay isang hanay ng mga bagay na may parehong uri na lohikal na konektado sa isa't isa. Ang likas na katangian ng mga koneksyon sa pagitan ng mga bagay ay ipinahiwatig lamang ng programmer at sa anumang paraan ay hindi kinokontrol ng Turbo Pascal. ang bilang ng mga elementong kasama sa isang set ay maaaring mag-iba mula 0 hanggang 256 (isang set na hindi naglalaman ng mga elemento ay tinatawag na empty).

Ang dalawang set ay itinuturing na katumbas kung at kung ang lahat ng kanilang mga elemento ay pareho, at ang pagkakasunud-sunod ng mga elemento ng set ay walang malasakit. Kung ang lahat ng elemento ng isang set ay kasama rin sa isa pa, ang unang set ay sinasabing kasama sa pangalawa.

Ang paglalarawan ng uri ng hanay ay:

< Pangalanuri>=SET NG< mga base. uri>

Dito<имя типа>- tamang identifier;

SET, OF – nakalaan na salita (set, of);

<баз.тип>- ang batayang uri ng mga elemento ng hanay, na maaaring maging anumang uri ng ordinal maliban sa WORD, INTEGER at LONGINT.

Upang tukuyin ang isang set, ang tinatawag na set constructor ay ginagamit: isang listahan ng mga detalye ng mga elemento ng set, na pinaghihiwalay ng mga kuwit; ang listahan ay napapalibutan ng mga square bracket. Ang mga pagtutukoy ng elemento ay maaaring mga constant o mga expression ng isang uri ng base, pati na rin isang uri ng hanay ng parehong uri ng base.

4. Mga file

Ang isang file ay nauunawaan bilang alinman sa isang pinangalanang lugar ng panlabas na memorya ng isang PC, o isang lohikal na aparato - isang potensyal na mapagkukunan o tagatanggap ng impormasyon.

Ang anumang file ay may tatlong katangiang katangian

mayroon itong pangalan, na nagpapahintulot sa programa na gumana sa ilang mga file nang sabay-sabay.

naglalaman ito ng mga bahagi ng parehong uri. Ang uri ng bahagi ay maaaring anumang uri ng Turbo Pascal, maliban sa mga file. Sa madaling salita, hindi ka makakagawa ng "file ng mga file."

ang haba ng bagong likhang file ay hindi tinukoy sa anumang paraan kapag ito ay idineklara at nalilimitahan lamang ng kapasidad ng mga external memory device.

Maaaring tukuyin ang uri ng file o variable ng uri ng file sa isa sa tatlong paraan:

< Pangalan>= FILE NG< uri>;

< Pangalan>=TEXT;

<имя>= FILE;

Dito<имя>- pangalan ng uri ng file (tamang identifier);

FILE, NG – nakalaan na mga salita (file, mula sa);

TEXT – pangalan ng karaniwang uri ng text file;

<тип>- anumang uri ng Turbo Pascal, maliban sa mga file.

Depende sa paraan ng deklarasyon, tatlong uri ng mga file ang maaaring makilala:

· nag-type ng mga file (itinakda ng FILE OF... clause);

· mga text file (tinukoy bilang uri ng TEXT);

· hindi na-type na mga file (tinukoy ng uri ng FILE).

Tungkol sa pag-convert ng mga numeric na uri ng data ng Pascal

Sa Pascal, ang mga implicit (awtomatikong) conversion ng mga numeric na uri ng data ay halos imposible. Ang isang pagbubukod ay ginawa lamang para sa uri ng integer, na pinapayagang gamitin sa mga expression ng totoong uri. Halimbawa, kung ang mga variable ay ipinahayag tulad nito:

Var X: integer; Y: totoo;

tapos yung operator

ay syntactically tama, bagama't mayroong isang integer expression sa kanan ng assignment sign at isang tunay na variable sa kaliwa, ang compiler ay awtomatikong magko-convert ng mga numeric data type. Ang reverse conversion na awtomatikong mula sa tunay na uri patungo sa integer na uri ay imposible sa Pascal. Tandaan natin kung gaano karaming mga byte ang inilalaan para sa mga variable na may uri ng integer at tunay: 2 byte ng memory ang inilalaan para sa integer na uri ng data na integer, at 6 na byte para sa tunay. Mayroong dalawang built-in na function para sa pag-convert ng real sa integer: round(x) rounds a real x to the nearest integer, trunc(x) truncates a real sa pamamagitan ng pag-discard ng fractional na bahagi.