ថ្នាក់ TList ត្រូវបានរចនាឡើងដើម្បីរក្សាទុកបញ្ជីចង្អុលទៅរចនាសម្ព័ន្ធដែលមានទីតាំងក្នុងចន្លោះអាសយដ្ឋាន (វត្ថុ អារេថាមវន្ត អថេរ)។ ដូច TstringList ដែរ បញ្ជីទ្រនិចបង្ហាញ ការងារប្រកបដោយប្រសិទ្ធភាពជាមួយធាតុបញ្ជី។
ថ្នាក់ TList
ស្នូលនៃថ្នាក់ TList គឺជាបញ្ជីនៃទ្រនិច។ បញ្ជីខ្លួនវាគឺជាអារេថាមវន្តនៃទ្រនិចដែលអាចចូលប្រើបានតាមរយៈលក្ខណៈសម្បត្តិដែលបានធ្វើលិបិក្រម
វត្ថុទ្រព្យ៖ ទ្រនិច;
លេខរៀងនៃធាតុចាប់ផ្តើមពីសូន្យ។
ការចូលទៅកាន់ធាតុអារេដោយផ្ទាល់គឺអាចធ្វើទៅបានតាមរយៈលក្ខណសម្បត្តិ
ប្រភេទ
PPointerList = ^TPointerList;
TPointerList = អារេនៃទ្រនិច;
បញ្ជីទ្រព្យសម្បត្តិ៖ PPointerList;
ដែលមានគុណលក្ខណៈបានតែអាន។
ចាប់តាំងពីធាតុបញ្ជីគឺជាចង្អុលទៅរចនាសម្ព័ន្ធមួយចំនួន ចូលដោយផ្ទាល់ សមាសធាតុនៃរចនាសម្ព័ន្ធទាំងនេះតាមរយៈទ្រព្យសម្បត្តិធាតុគឺមិនអាចទៅរួចទេ។
របៀបដែលនេះអាចត្រូវបានធ្វើត្រូវបានពិពណ៌នានៅក្នុងឧទាហរណ៍ខាងក្រោម។
ចំណាំ
បញ្ជីនេះអាចផ្ទុកនូវចំណុចចង្អុលទៅរចនាសម្ព័ន្ធផ្សេងៗគ្នា។ វាមិនចាំបាច់ក្នុងការរក្សាទុកតែចង្អុលទៅវត្ថុ ឬទ្រនិចដើម្បីកត់ត្រាក្នុងបញ្ជីនោះទេ។
ប្រតិបត្តិការបញ្ជីដែលបានអនុវត្តនៅក្នុងថ្នាក់ TList បំពេញតម្រូវការរបស់អ្នកអភិវឌ្ឍន៍ ហើយស្របគ្នាជាមួយនឹងប្រតិបត្តិការនៃបញ្ជីខ្សែអក្សរ។
ដើម្បីបន្ថែមទ្រនិចថ្មីទៅចុងបញ្ចប់នៃបញ្ជី សូមប្រើវិធីសាស្ត្រ
មុខងារបន្ថែម (ធាតុ៖ ទ្រនិច)៖ ចំនួនគត់;
ការកំណត់តម្លៃដោយផ្ទាល់ទៅធាតុដែលមិនទាន់ត្រូវបានបង្កើតដោយប្រើវិធីសាស្ត្របន្ថែមនឹងបណ្តាលឱ្យមានកំហុសពេលដំណើរការ។
សន្ទស្សន៍ថ្មីអាចត្រូវបានបន្ថែមទៅទីតាំងដែលចង់បាននៅក្នុងបញ្ជី។ ចំពោះគោលបំណងនេះវិធីសាស្រ្តត្រូវបានប្រើ
នីតិវិធីបញ្ចូល(សន្ទស្សន៍៖ ចំនួនគត់; ធាតុ៖ ទ្រនិច);
ប៉ារ៉ាម៉ែត្រលិបិក្រមបញ្ជាក់លេខលំដាប់ដែលត្រូវការនៅក្នុងបញ្ជី។
ការផ្ទេរធាតុដែលមានស្រាប់ទៅទីតាំងថ្មីត្រូវបានអនុវត្តដោយប្រើវិធីសាស្ត្រ
នីតិវិធីផ្លាស់ទី (Curlndex, Newlndex: ចំនួនគត់);
ប៉ារ៉ាម៉ែត្រ CurIndex បញ្ជាក់ទីតាំងទ្រនិចចាស់។ ប៉ារ៉ាម៉ែត្រ NewIndex បញ្ជាក់ទីតាំងថ្មីរបស់វា។
អ្នកក៏អាចប្តូរធាតុពីរដែលកំណត់ដោយប៉ារ៉ាម៉ែត្រ Indexl និង Index2៖
ការផ្លាស់ប្តូរនីតិវិធី (សន្ទស្សន៍, សន្ទស្សន៍ ២៖ ចំនួនគត់);
មានវិធីពីរយ៉ាងដែលប្រើដើម្បីដកទ្រនិចចេញពីបញ្ជី។ ប្រសិនបើលិបិក្រមត្រូវបានគេស្គាល់ វិធីសាស្ត្រត្រូវបានប្រើ
នីតិវិធីលុប (សន្ទស្សន៍៖ ចំនួនគត់);
ប្រសិនបើទ្រនិចខ្លួនវាត្រូវបានគេស្គាល់ វិធីសាស្ត្រត្រូវបានប្រើ
វិធីសាស្រ្តទាំងនេះមិនកាត់បន្ថយចំនួនអង្គចងចាំដែលបានបែងចែកទៅក្នុងបញ្ជីនោះទេ។ បើចាំបាច់ អ្នកគួរតែប្រើសមត្ថភាពសមត្ថភាពដើម្បីធ្វើកិច្ចការនេះ។ វាក៏មានវិធីសាស្ត្រពង្រីកដែលបង្កើនអង្គចងចាំដែលបានបម្រុងទុកដោយស្វ័យប្រវត្តិអាស្រ័យលើទំហំបច្ចុប្បន្ននៃបញ្ជី។
មុខងារពង្រីក៖ TList;
ដើម្បីឱ្យវិធីសាស្រ្តដំណើរការវាចាំបាច់ដែលរាប់ = សមត្ថភាព។
វិធីសាស្រ្ត
នីតិវិធីជម្រះ; ថាមវន្ត;
ប្រើដើម្បីលុបធាតុបញ្ជីទាំងអស់ក្នុងពេលតែមួយ។ ដើម្បីស្វែងរកទ្រនិចដោយតម្លៃរបស់វា សូមប្រើវិធីសាស្ត្រ
អនុគមន៍ IndexOf(Item: Pointer): ចំនួនគត់;
វិធីសាស្រ្តត្រឡប់លិបិក្រមនៃធាតុដែលបានរកឃើញក្នុងបញ្ជី។ ប្រសិនបើការស្វែងរកមិនជោគជ័យ វាត្រលប់មកវិញ - ១.
ដើម្បីតម្រៀបធាតុបញ្ជី សូមប្រើវិធីសាស្ត្រ
ដំណើរការតម្រៀប (ប្រៀបធៀប៖ TListSortCompare);
ចាប់តាំងពីសមាសភាពនៃរចនាសម្ព័ន្ធដែលចំណុចធាតុបញ្ជីមិនអាចត្រូវបានគេទូទៅជាមុន ការអភិវឌ្ឍន៍នៃនីតិវិធីដែលអនុវត្តការតម្រៀបត្រូវបានប្រគល់ឱ្យអ្នកសរសេរកម្មវិធី។ វិធីសាស្ត្រតម្រៀបផ្តល់នូវការប្រៀបធៀបជាគូនៃទ្រនិចដោយផ្អែកលើក្បួនដោះស្រាយដែលបង្កើតឡើងដោយអ្នកសរសេរកម្មវិធី (សម្រាប់ឧទាហរណ៍នៃការតម្រៀប សូមមើលខាងលើនៅក្នុងផ្នែក "TStringList Class")។
លក្ខណៈសម្បត្តិ និងវិធីសាស្រ្តទាំងអស់នៃថ្នាក់ TList ត្រូវបានបង្ហាញនៅក្នុងតារាង។ ៧.២.
តារាង 7.2 ។ លក្ខណៈសម្បត្តិ និងវិធីសាស្រ្តនៃថ្នាក់ TList
សេចក្តីប្រកាស
ការពិពណ៌នា
សមត្ថភាពទ្រព្យសម្បត្តិ៖ ចំនួនគត់;
កំណត់ចំនួនជួរដេកដែលអង្គចងចាំត្រូវបានបែងចែក
ចំនួនទ្រព្យ៖ ចំនួនគត់;
ត្រឡប់ចំនួនជួរដេកក្នុងបញ្ជីមួយ។
វត្ថុទ្រព្យ៖ ទ្រនិច;
បញ្ជីចង្អុលបង្ហាញ
ប្រភេទ
TPointerList = អារេនៃទ្រនិច;
PPointerList = បញ្ជី ATPointerList; បញ្ជីទ្រព្យសម្បត្តិ៖ PPointerList;
អារេថាមវន្តចង្អុល
មុខងារបន្ថែម (ធាតុ៖ ទ្រនិច)៖ ចំនួនគត់;
បន្ថែមទ្រនិចថ្មីទៅក្នុងបញ្ជី
នីតិវិធីជម្រះ; ថាមវន្ត;
ជម្រះបញ្ជីទាំងស្រុង
នីតិវិធីលុប (សន្ទស្សន៍៖ ចំនួនគត់៖;
លុបទ្រនិចជាមួយលិបិក្រម
សន្ទស្សន៍
ដំណើរការថ្នាក់ Error (const Ksg: string; Data: Integer); និម្មិត;
បង្កើតភាពពិសេស
ស្ថានភាព ElistError ។
សារកំហុសត្រូវបានបង្កើតចេញពីខ្សែអក្សរទម្រង់ Msg និងប៉ារ៉ាម៉ែត្រទិន្នន័យជាលេខ
ការផ្លាស់ប្តូរនីតិវិធី (សន្ទស្សន៍ សន្ទស្សន៍ ២៖ ចំនួនគត់);
ប្ដូរទ្រនិចជាមួយសន្ទស្សន៍និងសន្ទស្សន៍ ២
មុខងារពង្រីក៖ TList;
បង្កើនទំហំអង្គចងចាំដែលបានបម្រុងទុកសម្រាប់បញ្ជី
មុខងារទីមួយ៖ ទ្រនិច;
ត្រឡប់ទ្រនិចទីមួយពីបញ្ជីមួយ។
អនុគមន៍ IndexOf(Item: Pointer): ចំនួនគត់;
ត្រឡប់សន្ទស្សន៍នៃទ្រនិច, កំណត់ដោយប៉ារ៉ាម៉ែត្រធាតុ
នីតិវិធីបញ្ចូល (សន្ទស្សន៍៖ ចំនួនគត់; ធាតុ៖ ទ្រនិច);
បញ្ចូល ធាតុថ្មី។សន្ទស្សន៍ទីតាំងធាតុ
មុខងារចុងក្រោយ៖ ទ្រនិច;
ត្រឡប់ទ្រនិចចុងក្រោយក្នុងបញ្ជី
នីតិវិធីផ្លាស់ទី (Curlndex, Newlndex: ចំនួនគត់);
ផ្លាស់ទីធាតុបញ្ជីទៅទីតាំងថ្មី។
កញ្ចប់នីតិវិធី;
ដកទ្រនិចទទេ (Nil) ទាំងអស់ចេញពីបញ្ជី
មុខងារ Remove(Item: Pointer): ចំនួនគត់;
ដកទ្រនិចចេញពីបញ្ជី
ធាតុ
វាយ TListSortCompare = អនុគមន៍ (ធាតុ ធាតុ ២៖ ទ្រនិច)៖ ចំនួនគត់;
ដំណើរការតម្រៀប (ប្រៀបធៀប៖ TListSortCompare);
តម្រៀបធាតុបញ្ជី
ឧទាហរណ៍នៃការប្រើប្រាស់បញ្ជីចង្អុល
សូមក្រឡេកមើលការប្រើប្រាស់បញ្ជីចង្អុលដោយប្រើឧទាហរណ៍នៃកម្មវិធី DemoList ។
នៅពេលអ្នកចុចលើទម្រង់ពាក្យសុំ ចំនុចមួយត្រូវបានបង្ហាញ និងផ្តល់លេខសៀរៀល។ ក្នុងពេលជាមួយគ្នានេះ កូអរដោនេ និងលេខចំណុចត្រូវបានសរសេរទៅលក្ខណៈសម្បត្តិដែលត្រូវគ្នានៃឧទាហរណ៍ដែលបានបង្កើតនៃថ្នាក់ TMypixel ។ ទ្រនិចទៅវត្ថុនេះត្រូវបានបញ្ជូនទៅ pixList ថ្មី។
ជាលទ្ធផល បន្ទាប់ពីសម្អាតទម្រង់ លំដាប់ពិន្ទុទាំងមូលអាចត្រូវបានស្ដារឡើងវិញដោយប្រើព្រួញចង្អុលទៅវត្ថុពីបញ្ជី។
បញ្ជីពិន្ទុអាចត្រូវបានតម្រៀបដោយ X កូអរដោណេតាមលំដាប់ឡើង។
ការចុះបញ្ជី។ ម៉ូឌុលនៃទម្រង់សំខាន់នៃគម្រោង DemoList
ឯកតាសំខាន់;
ចំណុចប្រទាក់
ប្រើប្រាស់
Windows, សារ, SysUtils, ថ្នាក់, ក្រាហ្វិក, ការត្រួតពិនិត្យ, ទម្រង់,
ប្រភេទ
ប្រអប់, StdCtrls, ប៊ូតុង;
TMainForm = ថ្នាក់ (TForm)
ListBtn៖ TBitBtn;
ClearBtn៖ TBitBtn;
DelBtn៖ TBitBtn;
តម្រៀបBtn៖ TBitBtn;
នីតិវិធី FormCreate (អ្នកផ្ញើ៖ TObject);
នីតិវិធី FormClose(អ្នកផ្ញើ៖ TObject; var Action: TCloseAction);
នីតិវិធី FormMouseDown (អ្នកផ្ញើ៖ TObject; ប៊ូតុង៖ TMouseButton;
នីតិវិធី ListBtnClick(អ្នកផ្ញើ៖ TObject);
នីតិវិធី ClearBtnClick(អ្នកផ្ញើ៖ TObject);
នីតិវិធី DelBtnClick (អ្នកផ្ញើ៖ TObject);
នីតិវិធី SortBtnClick(អ្នកផ្ញើ៖ TObject);
ឯកជន
PixList: TList;
PixNum៖ ចំនួនគត់; សាធារណៈ
(សេចក្តីប្រកាសជាសាធារណៈ)
បញ្ចប់;
TMyPixel = ថ្នាក់(វត្ថុ)
fx: ចំនួនគត់;
FY: ចំនួនគត់;
FTtext: ចំនួនគត់;
អ្នកបង្កើតបង្កើត (X, Y, Num: ចំនួនគត់);
(សេចក្តីប្រកាសជាសាធារណៈ)
នីតិវិធី SetPixel;
var
ទម្រង់សំខាន់៖ TMainForm;
ការអនុវត្ត
($R *.DFM)
const PixColor = clRed;
var CurPixel៖ TMyPixel;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
ចាប់ផ្តើម
បង្កើតមរតក;
FX:=X;
FY:= Y;
FTtext:= លេខ;
(សេចក្តីប្រកាសជាសាធារណៈ)
SetPixel;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
នីតិវិធី TMyPixel.SetPixel;
MainForm.Canvas.PolyLine();
(សេចក្តីប្រកាសជាសាធារណៈ)
MainForm.Canvas.TextOut(FX +1, FY +1, IntToStr(FText));
អនុគមន៍ PixCompare(Iteml, Item2: Pointer): ចំនួនគត់;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
var Pixl, Pix2: TMyPixel;
Pixl:= ធាតុ;
Pix2:= Item2;
(សេចក្តីប្រកាសជាសាធារណៈ)
លទ្ធផល៖= Pixl.FX - Pix2.FX;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
នីតិវិធី TMainForm.FormCreate(អ្នកផ្ញើ៖ TObject);
PixList:= TList.Create;
PixNum:= 1; (ពិន្ទុរាប់)
Canvas.Pen.Color:= PixColor; (ពណ៌ចំណុច)
Canvas.Pen.Width:= 3; (ទំហំចំណុច)
(សេចក្តីប្រកាសជាសាធារណៈ)
Canvas.Brush.Color:= ពណ៌; (ពណ៌ផ្ទៃខាងក្រោយអត្ថបទគឺស្មើនឹងពណ៌ទម្រង់)
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
នីតិវិធី TMainForm.FormClose(អ្នកផ្ញើ៖ TObject; var Action: TCloseAction);
(សេចក្តីប្រកាសជាសាធារណៈ)
PixList.Free;
ការផ្លាស់ប្តូរ៖ TShiftState; X, Y: ចំនួនគត់);
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
PixList.Add(TMyPixel.Create(X, Y, PixNum));
Inc (PixNum);
(សេចក្តីប្រកាសជាសាធារណៈ)
នីតិវិធី TMainForm.ListBtnClick(អ្នកផ្ញើ៖ TObject);
var i: ចំនួនគត់;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
ជាមួយ PixList ធ្វើ
សម្រាប់ i:= 0 ដើម្បីរាប់ - 1 ធ្វើ
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
CurPixel:= ធាតុ[i]; CurPixel.SetPixel;
បញ្ចប់; បញ្ចប់;
នីតិវិធី TMainForm.ClearBtnClick(អ្នកផ្ញើ៖ TObject);
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
Canvas.FillRect(Rect(0, 0, Width, Height));
(សេចក្តីប្រកាសជាសាធារណៈ)
នីតិវិធី TMainForm.DelBtnClick(អ្នកផ្ញើ៖ TObject);
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
PixList.Clear;
PixNum:= 1;
(សេចក្តីប្រកាសជាសាធារណៈ)
នីតិវិធី TMainForm.SortBtnClick(អ្នកផ្ញើ៖ TObject);
var i: ចំនួនគត់;
អ្នកបង្កើត TMyPixel.Create(X, Y, Num: ចំនួនគត់);
PixList.Sort(PixCompare);
ជាមួយ PixList ធ្វើ
សម្រាប់ i:= 0 ដើម្បីរាប់ - 1 ធ្វើ TMyPixel(Items[i]).FText:= i + 1;
(សេចក្តីប្រកាសជាសាធារណៈ)
ចប់។
ថ្នាក់ TMyPixel ផ្តល់នូវការផ្ទុកកូអរដោនេនៃចំណុចមួយ និងលេខស៊េរីរបស់វានៅក្នុងស៊េរី។ ប៉ារ៉ាម៉ែត្រទាំងនេះត្រូវបានបញ្ជូនទៅអ្នកសាងសង់ថ្នាក់។ វិធីសាស្ត្រ setPixel ធានាថាចំណុចមួយត្រូវបានគូរនៅលើគ្រោងទម្រង់។
ឧទាហរណ៍នៃថ្នាក់ត្រូវបានបង្កើតសម្រាប់នីមួយៗ ចំណុចថ្មី។នៅពេលដែលប៊ូតុងកណ្ដុរត្រូវបានចុចនៅក្នុងវិធីដោះស្រាយ FormMouseDown ។ នេះគឺជាទ្រនិចទៅ វត្ថុថ្មី។រក្សាទុកក្នុងធាតុបញ្ជី PixList ដែលបង្កើតដោយប្រើវិធីសាស្ត្របន្ថែម។
ដូច្នេះកម្មវិធី "ចងចាំ" ទីតាំងនិងលំដាប់នៃចំណុច។
វិធីសាស្ត្រគ្រប់គ្រង ListBtnClick ធានាថាចំណុចត្រូវបានបង្ហាញ។ ដើម្បីធ្វើដូចនេះនៅក្នុងរង្វិលជុំ ទ្រនិចបញ្ជីបច្ចុប្បន្នត្រូវបានផ្ទេរទៅអថេរនៃប្រភេទវត្ថុ curPixel ពោលគឺអថេរនេះនឹងត្រូវបាន "ទៅមើល" នៅក្នុងវេនដោយវត្ថុដែលបានបង្កើតទាំងអស់ ទ្រនិចដែលត្រូវបានរក្សាទុកក្នុងបញ្ជី។
នេះត្រូវបានធ្វើក្នុងគោលបំណងដើម្បីទទួលបានការចូលប្រើលក្ខណៈសម្បត្តិរបស់វត្ថុ (វាមិនអាចធ្វើបានដោយផ្ទាល់តាមរយៈទ្រនិច)។ វិធីសាស្ត្រខាសប្រភេទទីពីរត្រូវបានពិភាក្សានៅក្នុងវិធីដោះស្រាយ SortBtnClick ។
មុនពេលបង្ហាញចំណុចម្តងទៀត ផ្ទៃនៃទម្រង់ត្រូវតែសម្អាត។
ប្រតិបត្តិការនេះត្រូវបានអនុវត្តដោយវិធីដោះស្រាយ clearBtnClick ។ បញ្ជីពិន្ទុអាចត្រូវបានតម្រៀបដោយ X កូអរដោណេតាមលំដាប់ឡើង។ដើម្បីធ្វើដូច្នេះ វិធីសាស្ត្រតម្រៀបនៃ PixList ត្រូវបានគេហៅថានៅក្នុងវិធីដោះស្រាយ SortBtnClick ។ ប៉ារ៉ាម៉ែត្រវិធីសាស្រ្ត (អថេរប្រភេទនីតិវិធី) ឆ្លងកាត់អនុគមន៍ PixCompare ដែលផ្តល់នូវយន្តការដែលរុំព័ទ្ធក្នុងវិធីសាស្ត្រតម្រៀបសម្រាប់ការរាប់បញ្ចូលធាតុបញ្ជីជាមួយនឹងក្បួនដោះស្រាយសម្រាប់ការសម្រេចចិត្តអាទិភាពនៃធាតុជាប់គ្នាពីរ។ ប្រសិនបើមុខងារត្រឡប់មកវិញលេខវិជ្ជមាន
ក្នុងករណីរបស់យើង កូអរដោនេ X នៃចំណុចពីរត្រូវបានប្រៀបធៀប។ ជាលទ្ធផលនៃការតម្រៀបឡើងនេះ វត្ថុត្រូវបានរៀបចំដូច្នេះធាតុទីមួយនៃបញ្ជីចង្អុលទៅវត្ថុដែលមានកូអរដោនេ X អប្បបរមា ហើយធាតុចុងក្រោយចង្អុលទៅវត្ថុដែលមានកូអរដោនេ X អតិបរមា។
បន្ទាប់ពីតម្រៀបហើយ អ្វីដែលនៅសល់គឺត្រូវរាប់ពិន្ទុទាំងអស់ឡើងវិញ។ វាធ្វើរង្វិលជុំនៅក្នុងវិធីដោះស្រាយ SortBtnclick ។ ចំណាំប្រភេទការខាសដែលបានប្រើក្នុងករណីនេះ ដែលផ្តល់នូវការចូលប្រើលក្ខណៈសម្បត្តិនៃវត្ថុនៃថ្នាក់ TMypixel ។
វិធីសាស្ត្រដោះស្រាយ DeiBtnClick ផ្តល់ជូន ការសម្អាតពេញលេញបញ្ជី pixList ។
សេចក្តីផ្តើម
1. និយមន័យនៃ ADT
3. ការពិពណ៌នាអំពីប្រតិបត្តិការ
3.1 បន្ថែមប្រតិបត្តិការធាតុ
3.2 ប្រតិបត្តិការនៃការបន្ថែមធាតុមួយបន្ទាប់ពីដែលបានបញ្ជាក់
3.3 លុបប្រតិបត្តិការ ធាតុដែលបានបញ្ជាក់
3.4 ប្រតិបត្តិការបោះពុម្ពធាតុបញ្ជី
4. ការអនុវត្ត ADT-list
4.1 មុខងារចម្បង
4.2 ចំណុចប្រទាក់
4.3 ការអនុវត្តវិធីសាស្រ្ត
សេចក្តីសន្និដ្ឋាន
ឯកសារយោង
ឧបសម្ព័ន្ធ A៖ ក្រាហ្វក្បួនដោះស្រាយ
សេចក្តីផ្តើម
ដោយមិនគិតពីប្រភេទនៃបញ្ហាដែលកំពុងត្រូវបានដោះស្រាយ កម្មវិធីណាមួយដំណើរការលើប្រភេទទិន្នន័យមួយចំនួន ហើយកម្មវិធីខ្លួនវាតំណាងឱ្យវិធីសាស្ត្រសម្រាប់គ្រប់គ្រង និងដំណើរការទិន្នន័យនេះ។ ល្បឿនដែលកម្មវិធីបំពេញកិច្ចការដែលបានផ្តល់ឱ្យមិនត្រឹមតែអាស្រ័យទៅលើក្បួនដោះស្រាយដែលវាប្រើដើម្បីដំណើរការ និងគ្រប់គ្រងទិន្នន័យប៉ុណ្ណោះទេ ប៉ុន្តែក៏អាស្រ័យលើការរៀបចំទិន្នន័យខ្លួនឯងផងដែរ។ ដូច្នេះយើងមកគំនិតនៃរចនាសម្ព័ន្ធទិន្នន័យ។
អន្តរកម្មដោយផ្ទាល់រវាងកម្មវិធីតាមរយៈអ្នកប្រើប្រាស់ និងរចនាសម្ព័ន្ធទិន្នន័យទុកបើកទិន្នន័យជាច្រើន ការកែប្រែដែលក្នុងវិធីដែលមិនស្របច្បាប់ (រំលងចំណុចប្រទាក់) អាចនាំឱ្យមានផលវិបាកដែលមិនចង់បាន។ ដើម្បីឆ្លងកាត់ បញ្ហានេះវាចាំបាច់ក្នុងការ "សាងសង់ជញ្ជាំង" រវាងទិន្នន័យនិងកម្មវិធីដោយបន្សល់ទុកតែ "បង្អួច" ក្នុងទម្រង់ជាចំណុចប្រទាក់។ ដើម្បីធ្វើដូចនេះវាចាំបាច់ដើម្បីកំណត់ប្រភេទទិន្នន័យអរូបីដែលជញ្ជាំងទាំងនេះត្រូវបានសាងសង់។
នៅក្នុងការងារនេះ ប្រភេទទិន្នន័យអរូបី (ADT) ត្រូវបានបង្កើតឡើង - បញ្ជីដែលត្រូវបានអនុវត្តជាបន្តបន្ទាប់ជាបញ្ជីភ្ជាប់ ដែលត្រូវបានអនុវត្តដោយប្រើប្រយោលផ្អែកលើទ្រនិច។ ការអភិវឌ្ឍនៃ ADT ត្រូវបានពិភាក្សាលម្អិតបន្ថែមទៀតនៅក្នុង។
1. និយមន័យនៃ ADT
អរូបីទិន្នន័យពិពណ៌នាអំពីអ្វីដែលអាចធ្វើបានជាមួយនឹងសំណុំទិន្នន័យដោយមិនអើពើនឹងសំណួរ "តើវាត្រូវបានធ្វើយ៉ាងដូចម្តេច?" ការអរូបីទិន្នន័យគឺជាវិធីមួយដើម្បីអភិវឌ្ឍ សមាសធាតុបុគ្គលកម្មវិធីដោយមិនគិតពីផ្នែកដែលនៅសល់របស់វា (សមាសធាតុផ្សេងទៀត)។ ដូច្នេះ ការអរូបីទិន្នន័យគឺជាផ្នែកបន្ថែមធម្មជាតិនៃមុខងារ abstraction ដែលអនុញ្ញាតឱ្យមុខងារត្រូវបានបង្កើតឡើងក្នុងភាពឯកោដែលទាក់ទងពីគ្នាទៅវិញទៅមក។ សំណុំនៃទិន្នន័យរួមបញ្ចូលគ្នាជាមួយសំណុំនៃប្រតិបត្តិការនៅលើវាត្រូវបានគេហៅថាប្រភេទទិន្នន័យអរូបី។ ការពិពណ៌នាអំពីប្រតិបត្តិការដែលបានរួមបញ្ចូលនៅក្នុង ADT ត្រូវតែមានភាពតឹងរ៉ឹងគ្រប់គ្រាន់ដើម្បីបង្ហាញយ៉ាងត្រឹមត្រូវនូវផលប៉ះពាល់របស់វាទៅលើទិន្នន័យ។ ប៉ុន្តែវាមិនគួរបញ្ជាក់ពីរបៀបដែលទិន្នន័យត្រូវបានរក្សាទុក ឬព័ត៌មានលម្អិតនៃប្រតិបត្តិការនោះទេ។ វិធីសាស្រ្តជាក់លាក់ការផ្ទុកទិន្នន័យ (រចនាសម្ព័ន្ធទិន្នន័យ) ត្រូវបានជ្រើសរើសតែនៅពេលអនុវត្ត ADT ប៉ុណ្ណោះ។ រចនាសម្ព័ន្ធទិន្នន័យ គឺជារចនាសម្ព័ន្ធដែលកំណត់ក្នុងភាសាសរសេរកម្មវិធីសម្រាប់រក្សាទុកសំណុំទិន្នន័យ។ យោងតាមជម្រើសកិច្ចការ ទិន្នន័យខាងក្រោមត្រូវបានកំណត់៖
1. ឈ្មោះរបស់បន្ទះឈីប
2. ការចំណាយ
3. បរិមាណ
ប្រតិបត្តិការខាងក្រោមត្រូវបានកំណត់លើពួកវា៖
1. បន្ថែមធាតុមួយទៅក្នុងបញ្ជីដែលមិនមានលំដាប់
2. ការដកធាតុដែលមានវាលដែលបានផ្តល់ឱ្យចេញពីបញ្ជីដែលមិនមានលំដាប់
3. បន្ថែមធាតុមួយបន្ទាប់ពីដែលបានបញ្ជាក់
4. ការលុបធាតុទាំងអស់ជាមួយនឹងវាលដែលបានផ្តល់ឱ្យ
5. បោះពុម្ពបញ្ជី
ឈុតនេះ។កំណត់សំណុំនៃប្រតិបត្តិការដែលអាចអនុញ្ញាតបានលើទិន្នន័យដែលបានកំណត់ក្នុងកិច្ចការ ពោលគឺឧ។ យើងត្រូវបានផ្តល់ប្រភេទទិន្នន័យអរូបី។
2. បទប្បញ្ញត្តិទូទៅ
បញ្ជីអរូបីអាចត្រូវបានអនុវត្តជាអារេមួយ - នៅ glance ដំបូង ជំហានជាក់ស្តែង។ អារេមាន ទំហំថេរ(នៅក្នុងភាសាសរសេរកម្មវិធីភាគច្រើន) ខណៈពេលដែលប្រវែងនៃបញ្ជីអរូបីគឺគ្មានដែនកំណត់។ ដូច្នេះរចនាសម្ព័ន្ធទិន្នន័យក្លាយជាឋិតិវន្តដែលជាគុណវិបត្តិ។
មួយទៀត គុណវិបត្តិសំខាន់គឺជាការបន្តនៃអត្ថប្រយោជន៍នៃអារេ - ការរៀបចំបន្តបន្ទាប់គ្នានៃទិន្នន័យនៅក្នុងកោសិកាដែលនៅជាប់គ្នា និយាយម្យ៉ាងទៀតផលិតជាញឹកញាប់ ដូច្នេះទាមទារ ល្បឿនអតិបរមាការប្រតិបត្តិ ប្រតិបត្តិការដូចជាការបញ្ចូល និងលុបធាតុនាំឱ្យតម្រូវការផ្លាស់ប្តូរធាតុអារេ ការចំណាយ ម៉ោងបន្ថែម.
គោលការណ៍នៃការអនុវត្តបញ្ជីដែលមិនប្រើការផ្លាស់ប្តូរធាតុគឺផ្អែកលើអាសយដ្ឋានប្រយោល។ វិធីផ្សេងទៀតដើម្បីអនុវត្តបញ្ជីអរូបីត្រូវបានពិពណ៌នាលម្អិតនៅក្នុង។
ថ្នាំងនីមួយៗ បញ្ជីភ្ជាប់មានពីរផ្នែក៖ ទិន្នន័យខ្លួនវា និងចង្អុលទៅធាតុបន្ទាប់ - ថ្នាំងដូចគ្នា ឬ NULL ថេរ។
ចាប់តាំងពីយោងទៅតាមគោលការណ៍នៃ encapsulation ទិន្នន័យគួរតែត្រូវបានចូលប្រើបានតែតាមរយៈវិធីសាស្រ្តដែលបានកំណត់សម្រាប់គោលបំណងនេះ អ្នកបញ្ជាក់ការចូលប្រើឯកជនត្រូវបានកំណត់សម្រាប់ទិន្នន័យ។
យន្តការសម្រាប់បែងចែកអង្គចងចាំសម្រាប់ធាតុនៃបញ្ជីដែលផ្អែកលើទ្រនិចពាក់ព័ន្ធនឹង ការជ្រើសរើសថាមវន្តការចងចាំដោយប្រើ ប្រតិបត្តិករថ្មី។និងលុប។ ដូច្នេះនៅពេលបង្កើតធាតុថ្មី វាសមហេតុផលក្នុងការបែងចែកអង្គចងចាំសម្រាប់តែទិន្នន័យថ្មីប៉ុណ្ណោះ មិនមែនសម្រាប់តែរួចទៅហើយ វិធីសាស្រ្តជាក់លាក់- បញ្ជីប្រតិបត្តិការ។ ដូច្នេះវាចាំបាច់ក្នុងការដកវិធីសាស្រ្តចេញពីរចនាសម្ព័ន្ធទិន្នន័យ។ នៅក្នុងការងារនេះ បច្ចេកទេសមួយត្រូវបានប្រើដើម្បីពង្រីកចំណុចប្រទាក់ដោយបង្កើតរចនាសម្ព័ន្ធវិធីសាស្រ្ត - ថ្នាក់មិត្តភាពដែលវិធីសាស្ត្រមានសិទ្ធិចូលប្រើសមាជិកឯកជននៃថ្នាក់ថ្នាំង។
អ្នកអាចស្វែងយល់បន្ថែមអំពីគោលការណ៍នៃកម្មវិធីតម្រង់ទិសវត្ថុពី។
ចង្អុលទៅក្បាល និងកន្ទុយនៃបញ្ជីមួយត្រូវបានប្រកាសនៅក្នុងថ្នាក់បញ្ជី ព្រោះវាមានសារៈសំខាន់ចាំបាច់សម្រាប់ការអនុវត្តវិធីសាស្ត្រ ADT ខណៈពេលដែលសម្រាប់រចនាសម្ព័ន្ធទិន្នន័យខ្លួនវាមិនមានន័យតិចតួចបំផុត។
វិធីសាស្រ្តដែលមិនគួរកែប្រែទិន្នន័យតាមមធ្យោបាយណាមួយត្រូវបានប្រកាសដោយប្រើ ពាក្យគន្លឹះ const ។
អនុវត្តសកម្មភាពទាំងអស់ដូចទៅនឹងអថេរធម្មតា។ ដើម្បីធ្វើការជាមួយ ការចែកចាយថាមវន្តអង្គចងចាំគឺងាយស្រួលប្រើណាស់។ រចនាសម្ព័ន្ធពាក់ព័ន្ធទិន្នន័យ ដូចជាបញ្ជីភ្ជាប់តែមួយ។ ឧទាហរណ៍សាមញ្ញបំផុតនៃបញ្ជីគឺជាអារេដែលធាតុទាំងអស់របស់វាត្រូវបានរៀបចំតាមលំដាប់លំដោយ។ ប៉ុន្តែការតំណាងនេះមានគុណវិបត្តិយ៉ាងសំខាន់ - វាចាំបាច់ក្នុងការបញ្ជាក់ឱ្យបានត្រឹមត្រូវនូវចំនួនធាតុជាមុន ...
វិធីសាស្រ្តអភិវឌ្ឍន៍ ក្បួនដោះស្រាយប្រកបដោយប្រសិទ្ធភាពដើម្បីដោះស្រាយបញ្ហាណាមួយ អ្នកត្រូវសិក្សាពីខ្លឹមសាររបស់វា។ ជាញឹកញយ បញ្ហាអាចត្រូវបានបង្កើតជាភាសានៃទ្រឹស្តីសំណុំ ដែលជាកម្មសិទ្ធិរបស់សាខាមូលដ្ឋាននៃគណិតវិទ្យា។ ក្នុងករណីនេះក្បួនដោះស្រាយសម្រាប់ការដោះស្រាយវាអាចត្រូវបានបញ្ជាក់នៅក្នុងលក្ខខណ្ឌនៃប្រតិបត្តិការមូលដ្ឋានលើសំណុំ។ ការងារបែបនេះក៏រួមបញ្ចូលការងារផងដែរ។ ការទាញយកព័ត៌មានកន្លែងដែលបញ្ហាត្រូវបានដោះស្រាយ ...
ទិន្នន័យនឹងកាន់តែមានន័យ ប្រសិនបើវាត្រូវបានតម្រៀបតាមវិធីណាមួយ។ ជាញឹកញាប់អ្នកត្រូវតម្រៀបទិន្នន័យដោយច្រើន។ នៅក្នុងវិធីផ្សេងៗ. ទីពីរ ក្បួនដោះស្រាយតម្រៀបជាច្រើនគឺ ឧទាហរណ៍គួរឱ្យចាប់អារម្មណ៍ការសរសេរកម្មវិធី។ ពួកគេបង្ហាញពីបច្ចេកទេសសំខាន់ៗដូចជា ការបញ្ជាទិញដោយផ្នែក ការហៅឡើងវិញ ការដាក់បញ្ចូលគ្នាក្នុងបញ្ជី និងការរក្សាទុកដើមឈើគោលពីរនៅក្នុងអារេមួយ។ ទីបំផុតការតម្រៀប...
ថាមពល (ជំនួសឧបករណ៍ដំណើរការ) ពង្រីកសមត្ថភាព RAM, បន្ថែម ឧបករណ៍ខាងក្រៅ. ម៉ាស៊ីនមានសំណុំការណែនាំធំ ប្រព័ន្ធអភិវឌ្ឍន៍ កម្មវិធីរួមទាំងអ្នកបកប្រែសម្រាប់ភាសាសរសេរកម្មវិធី Assembly, FORTRAN, PL/1, COBOL, ALGOL, PASCAL, ប្រព័ន្ធប្រតិបត្តិការជាមួយនឹងមុខងារផ្សេងគ្នា។ មុខងារសំខាន់នៃកុំព្យូទ័របញ្ជា...
បញ្ជី តំណាងឱ្យការប្រមូលផ្តុំ វត្ថុថាមវន្តប្រភេទដូចគ្នា រៀបចំដោយប្រើតំណភ្ជាប់។
វត្ថុត្រូវបានគេហៅថាធាតុបញ្ជី។ ធាតុនៃបញ្ជីមួយជាធម្មតាជាធាតុដែលមាន យ៉ាងហោចណាស់, វាលពីរ (រូបភាព 2.13):
ព័ត៌មាន;
ទ្រនិច។
បញ្ជីខ្លួនវាត្រូវបានបង្ហាញជាទម្រង់រូបភព។ ២.១៤.
ធាតុបញ្ជីនីមួយៗមាន ទ្រនិចនៅលើអ្នកជិតខាង។ ធាតុចុងក្រោយមានទ្រនិច - និល. ធាតុបញ្ជី និងចង្អុលត្រូវបានពិពណ៌នាដូចខាងក្រោម៖
សន្ទស្សន៍ = ^El_List;(ការពិពណ៌នាជាមុន)
(អនុញ្ញាតតែក្នុងករណីនេះ)
E-List = កត់ត្រា
Inf._ វាល៖ Field_Info_Type;
Index_field៖ សន្ទស្សន៍; (ប្រភេទនេះត្រូវបានកំណត់ខាងលើរួចហើយ)
ប្រភេទនៃធាតុព័ត៌មានគឺណាមួយ (មាត្រដ្ឋាន ខ្សែអក្សរ អារេ ។ល។)។
ឧទាហរណ៍. ធបាទ
Ptr = ^ អែល;
El = កំណត់ត្រា
Buk: Char;
Ukaz: Ptr;
tUk, ព្រូក, NUk,q:Ptr;(ចង្អុលទៅធាតុបញ្ជី)
ElSp : អេល។; (ធាតុបញ្ជី (ប្រភេទកំណត់ត្រា អេល។) }
បញ្ជីធ្វើឱ្យមានភាពងាយស្រួលក្នុងការបង្ហាញ ជួរ.
ជួរគឺជាគំនិតមួយដែលត្រូវបានប្រើប្រាស់យ៉ាងទូលំទូលាយក្នុងការគណនា។ បញ្ជីអនុញ្ញាតឱ្យអ្នកធ្វើគំរូប្រតិបត្តិការនៃការបន្ថែមធាតុទៅជួរហើយជ្រើសរើសពីវា។
ប្រតិបត្តិការមូលដ្ឋានលើបញ្ជី៖
1) ការផ្លាស់ប្តូរពីធាតុមួយទៅធាតុមួយទៀត (បន្ទាប់);
2) ការដាក់បញ្ចូលធាតុថ្មីនៅក្នុងបញ្ជី;
3) ការដកធាតុចេញពីបញ្ជី។
1) ប្រតិបត្តិការដំបូងគឺសាមញ្ញ៖ តម្លៃនៃអថេរទ្រនិចដែលឥឡូវនេះចង្អុលទៅធាតុជាក់លាក់មួយ ត្រូវតែផ្តល់តម្លៃដែលមានទីតាំងនៅក្នុងវាលទ្រនិចនៃធាតុនេះ (សូមមើលរូប 2.15)៖
tUk := tUk^. អ៊ូកាស
IN 
លទ្ធផល tUkនឹងក្លាយជាតំណភ្ជាប់ទៅកាន់ធាតុបន្ទាប់ ឬ និលប្រសិនបើធាតុចុងក្រោយ។
2) ការដកយកចេញធាតុពីបញ្ជីត្រូវបានអនុវត្តយ៉ាងសាមញ្ញបំផុតប្រសិនបើមានតំណភ្ជាប់ (ទ្រនិច) ទៅធាតុ, មុន ដែលត្រូវលុប. ក្នុងករណីនេះតំណភ្ជាប់ត្រូវបានផ្ទេរដំបូងហើយបន្ទាប់មកធាតុត្រូវបានលុប (អង្គចងចាំថាមវន្តដែលវាកាន់កាប់ត្រូវបានដោះលែង) ។ សេចក្តីយោងចំពោះធាតុដែលត្រូវបានលុបមិនត្រូវបាត់បង់ឡើយ រហូតទាល់តែវាត្រូវបានបំផ្លាញ ឬបញ្ចូលក្នុងបញ្ជីមួយផ្សេងទៀត បើមិនដូច្នោះទេ វានឹងក្លាយជា "សំរាម"។
ដំណើរការនៃការដកធាតុដែលមានទីតាំងនៅក្នុងបញ្ជីបន្ទាប់ពីធាតុដែលចង្អុលទៅដោយតំណ ព្រូក, បានបង្ហាញនៅក្នុងរូបភព។ 2.16 និងបំណែកនៃកម្មវិធីដែលត្រូវគ្នាអាចមើលទៅដូចជាកម្មវិធីខាងក្រោម។
{
ចងចាំទ្រនិចទៅធាតុដែលត្រូវលុប)
tUk:= PrUk^.Ukaz;
(កំណត់វាលទ្រនិចនៃធាតុដែលត្រូវលុបមុន)
(តម្លៃនៃវាលទ្រនិចរបស់ធាតុដែលត្រូវដកចេញ)
PrUk^.Ukaz:= PrUk^.Ukaz^.Ukaz;
នៅលើនេះ។ ការលុបធាតុ ពីបញ្ជីបានបញ្ចប់៖ ការតភ្ជាប់នៃធាតុនេះជាមួយធាតុមុនត្រូវបានខូច។ ប៉ុន្តែធាតុបន្តកាន់កាប់អង្គចងចាំ ហើយដើម្បីលុបវាដោយរាងកាយ អ្នកត្រូវអនុវត្តនីតិវិធី៖
បោះចោល (tUk); (ដកធាតុចេញដោយរាងកាយ)
ប្រសិនបើមិនចាំបាច់ទំនេរអង្គចងចាំទេ ជួនកាលវាមានប្រយោជន៍ក្នុងការសរសេរទៅកាន់វាលទ្រនិចធាតុដែលបានលុប និល:
tUk^.Ukaz:= នីល។
3
)ការបើកដំណើរការទៅបញ្ជីធាតុដែលមានទ្រនិច នចក្រភពអង់គ្លេសបន្ទាប់ពីធាតុដែលមានទ្រនិច ព្រូក, បានបង្ហាញនៅក្នុងរូបភព។ ២.១៧. ដើម្បីអនុវត្តប្រតិបត្តិការនេះ អ្នកត្រូវកំណត់តំណពីធាតុដែលបានបញ្ចូលទៅធាតុបន្ទាប់ (វាស្មើនឹងតំណភ្ជាប់ពីធាតុមុនទៅធាតុបន្ទាប់ - សូមមើលរូប 2.17, ក) ហើយបន្ទាប់មកប្តូរតំណពី ធាតុមុនទៅនឹងធាតុដែលបានបញ្ចូល (សូមមើលរូប 2.17, ខ) ។ ការតភ្ជាប់ដែលមានស្រាប់ត្រូវបានខូចចុងក្រោយដើម្បីកុំឱ្យបាត់បង់ធាតុ។
បំណែកនៃកម្មវិធីនឹងមើលទៅដូច
ថ្មី (NUk);
(បង្កើតធាតុបញ្ចូល)
