განმარტების მოდულში გამოცხადებული აბსტრაქტული ტიპი. აბსტრაქტული მონაცემთა ტიპი. აბსტრაქტული მონაცემთა ტიპი "ხე"

ყველა ჩაშენებული მონაცემთა ტიპი აბსტრაქტულია, თუმცა მათ ასე იშვიათად უწოდებენ.

აბსტრაქციის ცნება

აბსტრაქცია არის განსჯა ან იდეა რაიმე ობიექტის შესახებ, რომელიც შეიცავს მხოლოდ მოცემულ კონტექსტში არსებით თვისებებს. აბსტრაქცია საშუალებას გაძლევთ დააკავშიროთ ობიექტების ინსტანციები ჯგუფებად, რომლებშიც არ არის საჭირო ობიექტების ზოგადი თვისებების გათვალისწინება, ე.ი. აბსტრაქტი მათგან. აბსტრაქცია პროგრამირების სირთულის ეფექტური ანტიდოტია, რაც პროგრამისტს საშუალებას აძლევს, ყურადღება გაამახვილოს ობიექტების არსებით თვისებებზე. აბსტრაქციის სახეები: პროცესის აბსტრაქციადა მონაცემთა აბსტრაქცია.

პროცესის აბსტრაქცია.ყველა რუტინა არის პროცესის აბსტრაქცია, ისინი განსაზღვრავენ იმ გზას, რომლითაც პროგრამა განსაზღვრავს, რომ გარკვეული პროცესი უნდა შესრულდეს, დეტალების დაზუსტების გარეშე, თუ როგორ უნდა გაკეთდეს ეს. ალგორითმის მრავალი დეტალისგან აბსტრაქციის უნარი, რომელსაც ქვეპროგრამა ახორციელებს, შესაძლებელს ხდის დიდი პროგრამების შექმნას, წაკითხვას და გაგებას. ნებისმიერი მონაცემთა აბსტრაქცია არის ოპერაციები, რომლებიც განსაზღვრულია როგორც პროცესის აბსტრაქცია.

მონაცემთა აბსტრაქცია.აბსტრაქტული მონაცემთა ტიპი არის ინკაფსულაცია, რომელიც შეიცავს მხოლოდ ერთი კონკრეტული ტიპის მონაცემთა და რუტინების წარმოდგენებს, რომლებიც ასრულებენ ოპერაციებს ამ მონაცემთა ტიპზე. წვდომის კონტროლის გამოყენებით, ტიპის აღწერილობის უმნიშვნელო დეტალები შეიძლება დამალული იყოს გარე მოდულებიდან, რომლებიც იყენებენ ამ ტიპს. პროგრამის მოდულებს, რომლებიც იყენებენ აბსტრაქტულ მონაცემთა ტიპს, შეუძლიათ გამოაცხადონ ამ ტიპის ცვლადები, მიუხედავად იმისა, რომ ამ ტიპის რეალური წარმოდგენა მათგან იმალება. აბსტრაქტული მონაცემთა ტიპის მაგალითს ეწოდება ობიექტი.

მონაცემთა ტიპის აბსტრაქციისა და პროცესის აბსტრაქციის შექმნის მიზეზი არის როგორც სირთულის საწინააღმდეგო საშუალება, დიდი და/ან რთული პროგრამების უფრო მართვადი.

კაფსულაცია

პროგრამის დაყოფა სინტაქსურ კონტეინერებად, რომლებიც შეიცავს ლოგიკურად დაკავშირებული რუტინებისა და მონაცემების ჯგუფებს. ამ სინტაქსურ კონტეინერებს ეწოდება მოდულები, ხოლო მათი განვითარების პროცესს ეწოდება მოდულირება.

პროგრამის შედგენა ქვეპროგრამებისა და მონაცემების კოლექციებიდან, რომელთაგან თითოეული შეიძლება ცალ-ცალკე შედგეს დანარჩენი პროგრამის ხელახალი კომპილაციის გარეშე. ამ კომპლექტს ეწოდება კომპილაციის ერთეული.

ინკაფსულაცია არის ქვეპროგრამების და მათ მიერ დამუშავებული მონაცემების ერთ მთლიანობაში გაერთიანების საშუალება. აბსტრაქტული სისტემის საფუძველი და შესაბამისი გამოთვლების ნაკრების ლოგიკური ორგანიზება, რომელიც შედგენილია ცალკე ან დამოუკიდებლად, არის კაფსულაცია.

მომხმარებლის მიერ განსაზღვრული მონაცემთა ტიპები

მომხმარებლის მიერ განსაზღვრულ მონაცემთა აბსტრაქტულ ტიპებს უნდა ჰქონდეთ შემდეგი თვისებები:

1) ტიპის განსაზღვრება, რომელიც საშუალებას აძლევს პროგრამის მოდულებს განაცხადონ ამ ტიპის ცვლადები, ხოლო მეხსიერებაში შექმნან ამ ცვლადების რეალური წარმოდგენა.

2) ოპერაციების ნაკრები მოცემული ტიპის ობიექტების მანიპულირებისთვის.

აბსტრაქტული მონაცემთა ტიპის ფორმალური განმარტება მომხმარებლის მიერ განსაზღვრული ტიპების კონტექსტში: აბსტრაქტული მონაცემთა ტიპი არის მონაცემთა ტიპი, რომელიც აკმაყოფილებს შემდეგ ორ პირობას.

წარმოდგენა (ტიპის განსაზღვრა) და ოპერაციები მოცემული ტიპის ობიექტებზე მოცემულია მოცემული ტიპის სინტაქსურ ერთეულში, შეიძლება შეიქმნას სხვა მოდულებში.

მოცემული ტიპის ობიექტების წარმოდგენა იმალება პროგრამის მოდულებიდან, რომლებიც იყენებენ ამ ტიპის ოპერაციებს, შეიძლება შესრულდეს ობიექტებზე, რომლებიც პირდაპირ არის გათვალისწინებული ტიპის განსაზღვრებით.

ტიპის წარმოდგენისა და ოპერაციების ცალკე სინტაქსურ ერთეულში შეფუთვა საშუალებას იძლევა პროგრამის ორგანიზება ლოგიკურ ერთეულებად, რომლებიც შეიძლება ცალკე შედგენილი იყოს. მეორეც, შესაძლებელი ხდება პროგრამის ცალკეულ ნაწილში მოცემული ტიპის ობიექტების ან მათთან ოპერაციების წარმოდგენის შეცვლა. ტიპების წარმოდგენის დეტალების დამალვას აქვს უპირატესობები. კლიენტები ვერ „ხედავენ“ ობიექტის წარმოდგენის დეტალებს და მათი კოდი არ არის დამოკიდებული ამ წარმოდგენაზე. ამ გზით, ობიექტების წარმოდგენები შეიძლება შეიცვალოს ნებისმიერ დროს კლიენტის კოდში ცვლილებების მოთხოვნის გარეშე. ინფორმაციის დამალვის კიდევ ერთი აშკარა და მნიშვნელოვანი უპირატესობა გაზრდილი სანდოობაა. კლიენტებს არ შეუძლიათ პირდაპირ შეცვალონ ობიექტების ძირითადი წარმოდგენები, განზრახ ან შემთხვევით და, შესაბამისად, იზრდება ასეთი ობიექტების მთლიანობა. ობიექტების შეცვლა შესაძლებელია მხოლოდ ამ მიზნით გათვალისწინებული ოპერაციების გამოყენებით.

ტიპის განვითარების საკითხები

შესაძლებელი უნდა იყოს აბსტრაქციის კლიენტებისთვის თვალსაჩინო გახდეს ტიპის სახელი და ქვეპროგრამის სათაურები. ეს საშუალებას აძლევს კლიენტებს გამოაცხადონ აბსტრაქტული ტიპის ცვლადები და მანიპულირონ მათი მნიშვნელობებით. მიუხედავად იმისა, რომ ტიპის სახელი უნდა იყოს გარედან ხილული, მისი განმარტება უნდა იყოს დამალული.

ძალიან ცოტაა ჩვეულებრივი ჩაშენებული ოპერაციები, რომლებიც შეიძლება შესრულდეს აბსტრაქტული ტიპის ობიექტებზე, განსხვავებით ტიპის განსაზღვრებით გათვალისწინებული ოპერაციებისგან. ეს ოპერაციები მოიცავს დავალებებს და თანასწორობისა და უთანასწორობის ტესტებს. თუ ენა არ აძლევს მომხმარებლებს უფლებას გადატვირთონ დავალების ოპერატორი, მაშინ ის უნდა იყოს ჩაშენებული. თანასწორობისა და უთანასწორობის ტესტები ზოგ შემთხვევაში წინასწარ უნდა იყოს განსაზღვრული, ზოგ შემთხვევაში არა. ტიპის დიზაინერმა თავად უნდა განსაზღვროს ოპერაციები აბსტრაქტული მონაცემთა ტიპებისთვის.

Smalltalk, C++ და Java პირდაპირ მხარს უჭერენ მონაცემთა აბსტრაქტულ ტიპებს.

მონაცემთა აბსტრაქტული ტიპები C++-ში

Ada და Modula-2 ენები უზრუნველყოფენ ინკაპსულაციას, რომელიც შეიძლება გამოყენებულ იქნას აბსტრაქტული მონაცემთა ტიპების მოდელირებისთვის, ხოლო C++ შემოაქვს კლასის კონცეფციას, რომელიც პირდაპირ უჭერს მხარს მონაცემთა აბსტრაქტულ ტიპებს. C++-ში კლასები არის ტიპები, მაგრამ Ada პაკეტები და Modula-2 მოდულები არ არის ტიპები. იმპორტირებულია პაკეტები და მოდულები, რაც საშუალებას აძლევს იმპორტიორ პროგრამულ ერთეულს გამოაცხადოს პაკეტში ან მოდულში განსაზღვრული ნებისმიერი ტიპის ცვლადები. C++ პროგრამაში ცვლადები გამოცხადებულია, როგორც ერთეულები, რომლებსაც აქვთ მოცემული კლასის ტიპი. ამ გზით, კლასები ბევრად უფრო ჰგავს ჩაშენებულ ტიპებს, ვიდრე პაკეტებს ან მოდულებს. პროგრამულ ერთეულს, რომელიც ხედავს პაკეტს Ada-ში ან მოდულს Modula-2-ში, აქვს წვდომა ნებისმიერ საჯარო ერთეულზე უბრალოდ მათი სახელებით. C++ პროგრამის ერთეულს, რომელიც აცხადებს კლასის მაგალითს, ასევე აქვს წვდომა ამ კლასის ნებისმიერ საჯარო ერთეულზე, მაგრამ მხოლოდ ამ კლასის ინსტანციის მეშვეობით.

რუსეთის ფედერაციის განათლებისა და მეცნიერების სამინისტრო

ფედერალური სახელმწიფო საბიუჯეტო საგანმანათლებლო დაწესებულება

უმაღლესი პროფესიული განათლება

ნაციონალური ბირთვული კვლევითი უნივერსიტეტი "MEPhI"

დიმიტროვგრადის საინჟინრო და ტექნოლოგიების ინსტიტუტი

დეპარტამენტი Საინფორმაციო ტექნოლოგია

აღიარე დაცვაში "" 2012 წელი

უფროსი დეპარტამენტი რაკოვა ო.ა.

კურსის მუშაობა

დისციპლინის მიხედვით"ობიექტზე ორიენტირებული პროგრამირება"

თემა:"აბსტრაქტული მონაცემთა ტიპები. სიები"

დაასრულა: სტუდენტი გრ. VT-31

შაიაკოვი ა.ფ.

ხელმძღვანელი: ხელოვნება. IT დეპარტამენტის მასწავლებელი

ალენინი V.A.

სტანდარტების კონტროლერი: ხელოვნება. IT დეპარტამენტის მასწავლებელი

ალენინი V.A.

შეფასება:

დაცვის თარიღი:

დიმიტროვგრადი, 2012 წ

რუსეთის ფედერაციის განათლებისა და მეცნიერების სამინისტრო

ფედერალური სახელმწიფო საბიუჯეტო საგანმანათლებლო დაწესებულება

უმაღლესი პროფესიული განათლება

ნაციონალური ბირთვული კვლევითი უნივერსიტეტი "MEPhI"

დიმიტროვგრადის საინჟინრო და ტექნოლოგიების ინსტიტუტი

კურსის მუშაობისთვის

დისციპლინა: ობიექტზე ორიენტირებული პროგრამირება

თემა: მონაცემთა აბსტრაქტული ტიპები. სიები

შემსრულებელი: შაიაკოვი ა.ფ.

ხელმძღვანელი: ალენინი ვ.ა.

1.თეორიული ნაწილი:

აბსტრაქტული მონაცემთა ტიპები. ობიექტზე ორიენტირებული პროგრამირების კონცეფცია. ხაზოვანი ცალმხრივად დაკავშირებული სიები.

2.პრაქტიკული ნაწილი:

დაწერეთ პროგრამა C++-ში ობიექტზე ორიენტირებული სტრუქტურით ხაზოვანი ცალმხრივად დაკავშირებული სიების განსახორციელებლად.

სამუშაოს დასრულების დაგეგმილი ვადები:

თეორიული ნაწილი - 15% მე-5 კვირისთვის

პრაქტიკული ნაწილი – 80% მე-7 კვირისთვის

ექსპერიმენტული განყოფილება - ____% ____ კვირამდე

დაცვა - 100% მე-10 კვირამდე

დიზაინის მოთხოვნები:

საკურსო სამუშაოს გაანგარიშება და ახსნა-განმარტება წარმოდგენილი უნდა იყოს ელექტრონული და ნაბეჭდი ასლების სახით;

ანგარიშის მოცულობა უნდა იყოს მინიმუმ 20 საბეჭდი გვერდი, დანართების გამოკლებით

RPP-ს ხელს აწერს სტანდარტული კონტროლისთვის პასუხისმგებელი პირი

სამუშაო მენეჯერი _________________

შემსრულებელი _________________________________

გამოცემის თარიღი "_____" ___________ 2012 წ

შაიაკოვი A.F. თემა: აბსტრაქტული მონაცემთა ტიპები. LISTS, Coursework / DITI, No 230105.65-Dimitrovgrad, 2012. - 29 გვერდი, ნახ. 11, ბიბ. სახელი 10, განაცხადები 1.

საკვანძო სიტყვები: წრფივი ცალმხრივად დაკავშირებული სიები, C++, ობიექტზე ორიენტირებული პროგრამირება.

კვლევის ობიექტია წრფივი ცალმხრივად დაკავშირებული სიები.

სამუშაოს მიზანია წრფივი ცალმხრივად დაკავშირებული სიების შესწავლა და პროგრამის დაწერა C++-ში ობიექტზე ორიენტირებული სტრუქტურით მათი განსახორციელებლად.

დასკვნები: ამ ნაშრომში სრულად იქნა შესწავლილი წრფივი ცალმხრივად დაკავშირებული სიები და მეხსიერებაში მათი წარმოდგენის მეთოდები. C++-ზე დაწერილი პროგრამა სრულად შეესაბამება ობიექტზე ორიენტირებულ სტრუქტურას, სწორად და ეფექტურად ასრულებს თავის მთავარ ამოცანას - ხაზოვანი ცალმხრივად დაკავშირებული სიების განხორციელებას.

შესავალი 6

1 თეორიული ნაწილი 7

1.1 აბსტრაქტული მონაცემთა ტიპები. ხაზოვანი სიები 7

1.2 ობიექტზე ორიენტირებული პროგრამირების კონცეფცია 8

2 პრაქტიკული ნაწილი 15

3 ტესტირება 23

დასკვნა 25

გამოყენებული ლიტერატურა 26

დანართი A 27

შესავალი

ხშირად მონაცემებთან მუშაობისას შეუძლებელია იმის დადგენა, თუ რამდენი მეხსიერება იქნება საჭირო მის შესანახად, პროგრამის შესრულებისას საჭიროებისამებრ. ბლოკები ერთმანეთთან არის დაკავშირებული მაჩვენებლების გამოყენებით. მონაცემთა ორგანიზების ამ ხერხს ეწოდება დინამიური მონაცემთა სტრუქტურა, რადგან ის მდებარეობს დინამიურ მეხსიერებაში და მისი ზომა იცვლება პროგრამის შესრულების დროს.

დინამიური სტრუქტურებიდან ამ ნაშრომში გამოყენებულია ხაზოვანი სიები. დინამიურ სტრუქტურას, მასივის ან ჩანაწერისგან განსხვავებით, შეუძლია დაიკავოს RAM-ის არამიმდევრული არეები.

დინამიური სტრუქტურები ასევე ფართოდ გამოიყენება მონაცემთა უფრო ეფექტურად მუშაობისთვის, რომელთა ზომა ცნობილია, განსაკუთრებით დახარისხების პრობლემების გადასაჭრელად.

ნებისმიერი დინამიური სტრუქტურის ელემენტი შედგება ორი ნაწილისაგან: ინფორმაცია, რომლის შესანახადაც იქმნება სტრუქტურა და მაჩვენებლები, რომლებიც უზრუნველყოფენ ელემენტების ერთმანეთთან დაკავშირებას.

1. თეორიული ნაწილი

1.1 აბსტრაქტული მონაცემთა ტიპები. ხაზოვანი სიები

აბსტრაქტული მონაცემთა ტიპების კონცეფცია არის მთავარი პროგრამირებაში. აბსტრაქცია გულისხმობს განცალკევებას და ინტერფეისისა და განხორციელების დამოუკიდებელ განხილვას.

მონაცემთა აბსტრაქცია გულისხმობს აბსტრაქტული მონაცემთა ტიპების (ADTs) ან, ექვივალენტურად, მომხმარებლის მიერ შეყვანილი ახალი მონაცემთა ტიპების განსაზღვრას და განხილვას.

აბსტრაქტული მონაცემთა ტიპი არის მონაცემთა ერთობლიობა ოპერაციების ერთობლიობასთან ერთად, რომელიც შეიძლება შესრულდეს ამ მონაცემებზე.

ხაზოვანი სიები

ხაზოვან სიაში თითოეული ელემენტი დაკავშირებულია შემდეგთან და შესაძლოა წინასთან. პირველ შემთხვევაში, სიას უწოდებენ უბრალოდ მიბმულს, მეორეში - ორმაგად დაკავშირებულს. თუ ბოლო ელემენტს დააკავშირებთ მაჩვენებლით პირველს, მიიღებთ წრიულ სიას.

სიის თითოეული ელემენტი შეიცავს გასაღებს, რომელიც განსაზღვრავს ამ ელემენტს. გასაღები ჩვეულებრივ არის მთელი რიცხვი ან სტრიქონი და არის მონაცემთა ველის ნაწილი. სიათან მუშაობისას, მონაცემთა ველის სხვადასხვა ნაწილმა შეიძლება იმოქმედოს გასაღების როლში. სხვადასხვა სიის ელემენტების გასაღებები შეიძლება იყოს იგივე.

თქვენ შეგიძლიათ შეასრულოთ შემდეგი ოპერაციები სიებში:

სიის საწყისი ფორმირება (პირველი ელემენტის შექმნა);

სიის ბოლოს ელემენტის დამატება;

ელემენტის წაკითხვა მოცემული გასაღებით;

ელემენტის ჩასმა სიაში მითითებულ ადგილას (მოცემული გასაღებით ელემენტის წინ ან მის შემდეგ);

ელემენტის წაშლა მოცემული გასაღებით;

სიის შეკვეთა გასაღებით.

პროგრამაში სიასთან მუშაობისთვის, თქვენ უნდა განსაზღვროთ მაჩვენებლის მითითება მის დასაწყისში. სიის ბოლოს ახალი ელემენტების დამატების გასაადვილებლად, თქვენ ასევე შეგიძლიათ დაამატოთ მაჩვენებელი სიის ბოლოს.

1.2 ობიექტზე ორიენტირებული პროგრამირების კონცეფცია

პროგრამის შემუშავების ობიექტზე ორიენტირებული მეთოდების სფეროში ავტორიტეტის განმარტებით, გრადი ბუჩა, „ობიექტზე ორიენტირებული პროგრამირება (OOP) არის პროგრამირების მეთოდოლოგია, რომელიც ეფუძნება პროგრამის წარმოდგენას, როგორც ობიექტების კრებულს, რომელთაგან თითოეული არის გარკვეული კლასის იმპლემენტაცია (განსაკუთრებული ტიპის) და კლასები ქმნიან იერარქიას მემკვიდრეობითობის პრინციპებზე.

ობიექტზე ორიენტირებული მეთოდოლოგია, ისევე როგორც სტრუქტურული მეთოდოლოგია, შეიქმნა დიდი პროგრამული სისტემების განვითარების პროცესის დისციპლინირებისთვის და ამით მათი სირთულის და ღირებულების შემცირების მიზნით.

ობიექტზე ორიენტირებულ მეთოდოლოგიას აქვს იგივე მიზნები, რაც სტრუქტურულ მეთოდოლოგიას, მაგრამ მიმართავს მათ სხვა საწყისი წერტილიდან და, უმეტეს შემთხვევაში, საშუალებას გაძლევთ მართოთ უფრო რთული პროექტები, ვიდრე სტრუქტურული მეთოდოლოგია.

მოგეხსენებათ, პროექტის სირთულის მართვის ერთ-ერთი პრინციპია დაშლა. Gradi Booch განასხვავებს დაშლის ორ ტიპს: ალგორითმულ (როგორც ის უწოდებს დაშლას, რომელსაც მხარს უჭერს სტრუქტურული მეთოდები) და ობიექტზე ორიენტირებული, რომელთა შორის განსხვავება, მისი აზრით, შემდეგია: ”ალგორითმების მიხედვით დაყოფა ყურადღებას ამახვილებს მოვლენათა თანმიმდევრობაზე. და ობიექტების მიხედვით დაყოფა განსაკუთრებულ მნიშვნელობას ანიჭებს ფაქტორებს, რომლებიც გამომწვევნი არიან ან არიან ამ მოქმედებების გამოყენების ობიექტები.“

სხვა სიტყვებით რომ ვთქვათ, ალგორითმული დაშლა უფრო მეტად ითვალისწინებს რთული პრობლემის ნაწილებს შორის ურთიერთობების სტრუქტურას, ხოლო ობიექტზე ორიენტირებული დაშლა უფრო მეტ ყურადღებას აქცევს ურთიერთობების ბუნებას.

პრაქტიკაში, რეკომენდებულია ორივე ტიპის დაშლის გამოყენება: დიდი პროექტების შექმნისას, მიზანშეწონილია გამოიყენოთ ჯერ ობიექტზე ორიენტირებული მიდგომა, რათა შეიქმნას ობიექტების ზოგადი იერარქია, რომელიც ასახავს პროგრამირებადი ამოცანის არსს, შემდეგ კი გამოიყენოთ ალგორითმული დაშლა. მოდულებად პროგრამული პაკეტის შემუშავებისა და შენარჩუნების გასამარტივებლად.

OO პროგრამირება უდავოდ არის ერთ-ერთი ყველაზე საინტერესო სფერო პროფესიული პროგრამების განვითარებისთვის.

ობიექტები და კლასები

ობიექტზე ორიენტირებული პროგრამის ძირითადი ბლოკებია ობიექტები და კლასები. შინაარსის თვალსაზრისით, ობიექტი შეიძლება წარმოდგენილი იყოს როგორც რაღაც იგრძნობა ან წარმოსახვითი და კარგად განსაზღვრული ქცევა. ამრიგად, ობიექტის დანახვა, შეხება ან სულ მცირე მისი არსებობის შესახებ ცნობილია, მაგალითად, წარმოდგენილია როგორც ინფორმაცია, რომელიც ინახება კომპიუტერის მეხსიერებაში. მოდით განვსაზღვროთ ობიექტი GradiButch-ის აზრის დაცვით: ”ობიექტი არის მატერიალური არსება, რომელიც ნათლად ავლენს თავის ქცევას”.

ობიექტი ჩვენს ირგვლივ არსებული რეალობის ნაწილია, ანუ ის არსებობს დროში და სივრცეში (პროგრამაში ობიექტის კონცეფცია პირველად დაინერგა Simula ენაზე). ფორმალურად, ობიექტის განსაზღვრა საკმაოდ რთულია. ეს შეიძლება გაკეთდეს ზოგიერთი თვისების მეშვეობით, კერძოდ: ობიექტს აქვს მდგომარეობა, ქცევა და შეიძლება იყოს ცალსახად იდენტიფიცირებული (სხვა სიტყვებით რომ ვთქვათ, აქვს უნიკალური სახელი).

კლასი არის ობიექტების ერთობლიობა, რომლებსაც აქვთ საერთო სტრუქტურა და საერთო ქცევა. კლასი არის აღწერა (აბსტრაქცია), რომელიც გვიჩვენებს, თუ როგორ უნდა ავაშენოთ ამ კლასის ცვლადი, რომელიც არსებობს დროში და სივრცეში, რომელსაც ეწოდება ობიექტი. წინადადებების „კლასის ცვლადების აღწერა“ და „კლასის ობიექტების აღწერა“ მნიშვნელობა იგივეა.

ობიექტს აქვს მდგომარეობა, ქცევა და პასპორტი (მისი უნიკალური იდენტიფიკაციის საშუალება); ობიექტების სტრუქტურა და ქცევა აღწერილია იმ კლასებში, რომელთა ცვლადებია.

ახლა განვსაზღვროთ მდგომარეობის, ქცევისა და ობიექტის იდენტიფიკაციის ცნებები.

ობიექტის მდგომარეობა აერთიანებს მის ყველა მონაცემთა ველს (სტატიკური კომპონენტი, ანუ უცვლელი) და თითოეული ამ ველის მიმდინარე მნიშვნელობებს (დინამიური კომპონენტი, ანუ ჩვეულებრივ იცვლება).

ქცევა გამოხატავს ობიექტის მდგომარეობის ცვლილებების დინამიკას და მის რეაქციას შემოსულ შეტყობინებებზე, ე.ი. როგორ ცვლის ობიექტი თავის მდგომარეობას და ურთიერთქმედებს სხვა ობიექტებთან.

ობიექტის იდენტიფიკაცია (აღიარება) არის თვისება, რომელიც საშუალებას გაძლევთ განასხვავოთ ობიექტი იმავე ან სხვა კლასის სხვა ობიექტებისგან. იდენტიფიკაცია ხორციელდება უნიკალური სახელის (პასპორტის) მეშვეობით, რომელიც ენიჭება პროგრამის ობიექტს, ისევე როგორც სხვა ცვლადი.

ზემოთ უკვე ითქვა, რომ პროცედურული (ასევე მოდულარული) მიდგომა საშუალებას გაძლევთ შექმნათ პროგრამები, რომლებიც შედგება პროცედურების (ქვეპროცედურების) ნაკრებისგან, რომლებიც ახორციელებენ მოცემულ ალგორითმებს. მეორეს მხრივ, ობიექტზე ორიენტირებული მიდგომა წარმოადგენს პროგრამებს, როგორც ობიექტების ერთობლიობას, რომლებიც ურთიერთქმედებენ ერთმანეთთან. ობიექტები ურთიერთქმედებენ შეტყობინებების საშუალებით. დავუშვათ, რომ ჩვენი ობიექტი არის წრე. შემდეგ ამ ობიექტზე გაგზავნილი შეტყობინება შეიძლება იყოს: "დახატე საკუთარი თავი". როდესაც ვამბობთ, რომ შეტყობინება ეგზავნება ობიექტს, ჩვენ რეალურად ვუწოდებთ ამ ობიექტის ზოგიერთ ფუნქციას (ფუნქციის კომპონენტს). ასე რომ, ზემოთ მოცემულ მაგალითში ჩვენ გამოვიძახებთ ფუნქციას, რომელიც დახატავს წრეს ეკრანზე.

კაფსულაცია

ინკაფსულაცია არის ობიექტზე ორიენტირებული პროგრამირების ერთ-ერთი ფუნდამენტური პრინციპი, რომლის იდეაც მდგომარეობს იმაში, რომ ყველა თვისება და მეთოდი გაერთიანებულია ობიექტში.

თავად ტერმინი „ენკაფსულაცია“ მომდინარეობს ინგლისური სიტყვიდან encapsulate, რაც სიტყვასიტყვით ნიშნავს „კაფსულაში დალუქვას“ ან „გარსით დაფარვას“. ამრიგად, ობიექტი (კაფსულა) შეიცავს მეთოდებსა და თვისებებს (შინაარსს).

ინკაფსულაციის კონცეფცია შეიძლება განიხილებოდეს უფრო ფართო გაგებით, ობიექტზე ორიენტირებული პროგრამირების ფარგლებს სცილდება მთლიანად. თუ ვსაუბრობთ ინკაფსულაციაზე აბსტრაქციის უმაღლეს შესაძლო დონეზე, მაშინ ინკაფსულაცია შეიძლება ჩაითვალოს, როგორც ობიექტის უნარი შეიცავდეს სხვა ობიექტების გარკვეულ კომპლექტს. ამრიგად, კომპიუტერულ პროგრამასთან დაკავშირებით, შეგვიძლია ვთქვათ, რომ ის აერთიანებს რამდენიმე მოდულს, რომელთაგან თითოეული თავის მხრივ აერთიანებს ზოგიერთ ობიექტს, რომლებიც აერთიანებს მეთოდებსა და თვისებებს, რომლებიც, სხვათა შორის, ასევე შეიძლება იყოს ობიექტები და ა.შ.

ყოველივე ზემოაღნიშნულიდან გამომდინარე, ინკაფსულაციის სხვა წარმომადგენლობა შეიძლება ჩაითვალოს ნებისმიერი ხის სტრუქტურა, რომელშიც ნებისმიერი ხის კვანძი აერთიანებს მის უშუალო შვილებს, რომლებიც შეიძლება იყოს ფოთლები (პრიმიტივები, რომლებიც ვერაფერს თავს იკავებენ) ან სხვა კვანძები.

და მაინც, თუ ვსაუბრობთ ობიექტზე ორიენტირებულ პროგრამირებაზე, მაშინ ინკაპსულაცია არის მონაცემთა და მეთოდების ერთობლიობა ობიექტის შიგნით.

ხანდახან ობიექტზე ორიენტირებულ პროგრამირებაში ინკაფსულაციაზე საუბრისას, ინკაფსულაციის ცნება აიგივებულია „შავი ყუთის“ ან მონაცემთა დამალვის კონცეფციასთან, მაგრამ ეს არ არის იგივე. დიახ, ზოგიერთ ობიექტზე ორიენტირებულ პროგრამირების ენაში, ინკაფსულაციის გამოყენებით, დეველოპერს შეუძლია თავისი ობიექტი გახადოს შავ ყუთად, მაგრამ ეს ხორციელდება წვდომის მოდიფიკატორების გამოყენებით, რომლებიც ყველა ობიექტზე ორიენტირებულ პროგრამირების ენას არ აქვს. თავისთავად ინკაფსულაციის კონცეფცია ბევრად უფრო ფართოა. და უფრო მეტიც, ჩვენ შეგვიძლია ყველა თვისება და მეთოდი გარედან ხელმისაწვდომი გავხადოთ, ანუ შავ ყუთზე საუბარი არ შეიძლება იყოს, მაგრამ ინკაფსულაცია მაინც იქნება ნებისმიერ ობიექტში. მაშასადამე, მონაცემთა დამალვა წვდომის მოდიფიკატორების გამოყენებით არის ინკაპსულაციის შედეგი, მაგრამ ისინი არ არიან იდენტური ცნებები.

პირველი, ინკაფსულაციის წყალობით, ობიექტები აღარ არის უბრალოდ მომხმარებლის მიერ განსაზღვრული მონაცემთა სტრუქტურები, რომელთა მთავარი მიზანია უბრალოდ ლოგიკურად შეაერთონ რამდენიმე ცალკეული მონაცემთა ტიპი ახალი კომპოზიციური მონაცემთა ტიპის შიგნით. ინკაფსულაციის წყალობით, თითოეულ ობიექტს შეუძლია შეიცავდეს მონაცემებს, რომლებიც აღწერს ობიექტის მდგომარეობას და მის ქცევას, აღწერილი მეთოდების სახით. სხვა სიტყვებით რომ ვთქვათ, ობიექტზე ორიენტირებული პროგრამირების ობიექტმა შეწყვიტა პრიმიტიული პასიური მონაცემთა ტიპი, რომლის მართვა მთლიანად გარე გარემოზეა მიტოვებული, მაგრამ დაიწყო საკუთარი ქცევა, შეიძლება ითქვას, გარკვეული იქნება და ინტელექტი, გარე გავლენებზე აქტიური რეაგირების და მისი მდგომარეობის შეცვლა და საკუთარი კანონებისა და წესების შესაბამისად.

მეორე, ინკაფსულაცია გვაძლევს შესაძლებლობას გავაკონტროლოთ წვდომა ობიექტის მონაცემებზე. ხილვადობის შეზღუდვა ასევე შეიძლება ჩაითვალოს ობიექტის საკუთარი ნების გამოვლინებად - ობიექტი თავად წყვეტს, რა ქცევა ან თვისებები გახადოს ყველასთვის ხელმისაწვდომი, რა გახდეს ხელმისაწვდომი მხოლოდ საგნების გარკვეული წრისთვის და რა გახდეს სრულიად ინტიმური. რომელიც მას არ ეცოდინება არც ერთი სხვა ობიექტის შესახებ. რატომ, მაგრამ იმიტომ, რომ მხოლოდ თავად ობიექტმა იცის ზუსტად როგორ იმუშაოს მასთან და როგორ არა. შეიძლება ვისაუბროთ პროგრამირების ახალ ფილოსოფიაზეც კი, სადაც ობიექტები უფრო ჰგავს ობიექტებს, რომლებზეც გარკვეული მოქმედებები სრულდება, მაგრამ, ასე ვთქვათ, აბსტრაქტული სინთეზური ინტელექტის ახალი ფორმა, რომელთანაც ურთიერთქმედება შეიძლება სასურველი შედეგის მიღწევა.

და კიდევ ერთხელ ვიმეორებ, რომ ინკაფსულაციის წყალობით, ობიექტს შეიძლება ჰქონდეს გარკვეული ნებისყოფა, ინტელექტი და გარე გავლენებზე რეაგირების უნარი და არა იყოს მონაცემთა პასიური საცავი.

მემკვიდრეობა

მემკვიდრეობა არის ობიექტზე ორიენტირებული პროგრამირების ოთხი ყველაზე მნიშვნელოვანი მექანიზმიდან ერთ-ერთი (ენკაფსულაციასთან, პოლიმორფიზმთან და აბსტრაქციასთან ერთად), რომელიც საშუალებას გაძლევთ აღწეროთ ახალი კლასი არსებულზე (მშობელი), ხოლო მშობელი კლასის თვისებები და ფუნქციონირება. ნასესხებია ახალი კლასის მიერ.

სხვა სიტყვებით რომ ვთქვათ, შთამომავალი კლასი ახორციელებს უკვე არსებული კლასის (ბაზა კლასის) სპეციფიკაციას. ეს საშუალებას გაძლევთ მოექცეთ შთამომავალი კლასის ობიექტებს ისევე, როგორც საბაზისო კლასის ობიექტებს

მემკვიდრეობის სახეები

მარტივი მემკვიდრეობა

კლასს, საიდანაც მოხდა მემკვიდრეობა, ეწოდება საბაზო ან მშობელი კლასი. კლასებს, რომლებიც წარმოიქმნება საბაზისო კლასიდან, ეწოდება შთამომავლები, მემკვიდრეები ან წარმოებული კლასები.

ზოგიერთი ენა იყენებს აბსტრაქტულ კლასებს. აბსტრაქტული კლასი არის კლასი, რომელიც შეიცავს მინიმუმ ერთ აბსტრაქტულ მეთოდს, ის აღწერილია პროგრამაში, აქვს ველები, მეთოდები და არ შეიძლება გამოყენებულ იქნას უშუალოდ ობიექტის შესაქმნელად. ანუ, თქვენ შეგიძლიათ მიიღოთ მემკვიდრეობა მხოლოდ აბსტრაქტული კლასიდან. ობიექტები იქმნება მხოლოდ აბსტრაქტულიდან მემკვიდრეობით მიღებული კლასების საფუძველზე.

მაგალითად, აბსტრაქტული კლასი შეიძლება იყოს საბაზო კლასი „უნივერსიტეტის თანამშრომელი“, საიდანაც მემკვიდრეობით მიიღება კლასები „კურსდამთავრებული“, „პროფესორი“ და ა დაბადების“), კლასის ეს წევრები შეიძლება გამოცხადდეს საბაზო კლასში. პროგრამა ქმნის ობიექტებს კლასების „კურსდამთავრებული“ და „პროფესორი“ საფუძველზე, მაგრამ აზრი არ აქვს ობიექტის შექმნას კლასზე „უნივერსიტეტის თანამშრომელი“.

მრავალჯერადი მემკვიდრეობა

მრავალჯერადი მემკვიდრეობით კლასს შეიძლება ჰყავდეს ერთზე მეტი წინაპარი. ამ შემთხვევაში, კლასი მემკვიდრეობით იღებს ყველა წინაპრის მეთოდებს. ამ მიდგომის უპირატესობა არის უფრო დიდი მოქნილობა. მრავალჯერადი მემკვიდრეობა დანერგილია C++-ში. სხვა ენები, რომლებიც უზრუნველყოფენ ამ ფუნქციას, მოიცავს Python და Eiffel. მრავალჯერადი მემკვიდრეობა მხარდაჭერილია UML ენაზე.

მრავალჯერადი მემკვიდრეობა არის შეცდომების პოტენციური წყარო, რომელიც შეიძლება მოხდეს წინაპრებში იდენტური მეთოდების სახელების არსებობის გამო. ენებზე, რომლებიც განლაგებულია C++-ის მემკვიდრეებად (Java, C# და ა. ამ მექანიზმის გამოყენების გარეშე თითქმის ყოველთვის შეგიძლიათ. თუმცა, თუ ასეთი საჭიროება მაინც წარმოიქმნება, მაშინ, იმავე სახელწოდებით მემკვიდრეობითი მეთოდების გამოყენებაში კონფლიქტების გადასაჭრელად, შესაძლებელია, მაგალითად, გამოიყენოთ ხილვადობის გაფართოების ოპერაცია - „::“ - გამოიძახოთ კონკრეტული მეთოდი. კონკრეტული მშობელი.

წინაპრებში იდენტური მეთოდის სახელების არსებობის პრობლემის გადაჭრის მცდელობა გაკეთდა ეიფელის ენაზე, რომელშიც ახალი კლასის აღწერისას აუცილებელია ცალსახად მიუთითოთ თითოეული მემკვიდრე კლასის იმპორტირებული წევრები და მათი დასახელება ბავშვში. კლასი.

ობიექტზე ორიენტირებული პროგრამირების ენების უმეტესობა (C#, C++, Java, Delphi და ა. ეს მექანიზმი საშუალებას გაძლევთ დიდწილად შეცვალოთ მრავალჯერადი მემკვიდრეობა - ინტერფეისის მეთოდები აშკარად უნდა იყოს გადალახული, რაც გამორიცხავს შეცდომებს სხვადასხვა წინაპრების კლასის იდენტური მეთოდების ფუნქციონირების მემკვიდრეობით.

1. პრაქტიკული ნაწილი

პრობლემის გადასაჭრელად გამოიყენება ობიექტზე ორიენტირებული პროგრამის სტრუქტურა. პროგრამა წარმოდგენილია ორი კლასით და მთავარი cpp ფაილით, რომელიც შეიცავს მომხმარებლის ინტერფეისს სიებთან მუშაობის გასაადვილებლად.

cList კლასი არის წრფივი ცალმხრივად დაკავშირებული სია, რომელიც შედგება cElement კლასის ობიექტებისგან.

ceElement კლასს აქვს შემდეგი სტრუქტურა:

ceElement * შემდეგი;

~ceElement(void);

void setdata(int);

void setref(ceElement*);

cElement* getref();

int ტიპის მონაცემთა ველი შეიცავს სიის ელემენტის ციფრულ მნიშვნელობას, cElement* ტიპის შემდეგი ველი შეიცავს ბმულს სიის მომდევნო ელემენტთან. setdata და getdata მეთოდები გამოიყენება კლასის პირადი მონაცემების ველზე წვდომისთვის, რათა მიიღონ და დააყენონ ამ ველის მნიშვნელობა შესაბამისად. setref მეთოდი გამოიყენება ბმულის დასაყენებლად მიმდინარე სიის შემდეგ ელემენტზე, ხოლო getref გამოიყენება შემდეგ ელემენტზე გადასასვლელად.

void cElement::setdata(int sd)

int ceElement::getdata()

returnthis->მონაცემები;

void ceElement::setref(cElement* rf)

ceElement* ceElement::getref()

returnthis->next;

ამ მეთოდების დანერგვა ძალიან მარტივია, როგორც ჩანს მათი პროგრამის კოდებიდან ზემოთ წარმოდგენილი.

ახლა მოდით შევხედოთ cList კლასის სტრუქტურას

#include"ceElement.h"

ცელემენტი *თავი;

void Add(int);

void Insert(int, int);

void Remove(int);

void RemoveAll();

ეს კლასი შეიცავს ბმულს სიის მთავარ ელემენტთან - head, ტიპის ceElement*. ამ ბმულის შენახვა აუცილებელია მონაცემთა დამატების, წაშლისა და სიის ბეჭდვის ოპერაციების სწორად შესრულებისთვის. ფაქტია, რომ რომელიმე ზემოაღნიშნული ოპერაციის შესრულებისას, სიის ელემენტები ჩამოთვლილია სასურველზე მისასვლელად, რადგან სიას არ აქვს შემთხვევითი წვდომა ელემენტებზე, ამიტომ უფრო რაციონალურია ჩამოთვლის დაწყება „თავიდან“. ” სიიდან. სიის დასაწყისის ბმულის გარდა, ამ კლასის თითოეულ ობიექტს ექნება elcount ველი, რომელიც შეიცავს ელემენტების რაოდენობას სიაში.

მოდით გავაგრძელოთ ამ კლასის განხილვა სიებთან მუშაობისთვის მასში დანერგილი მეთოდების შესწავლით.

მეთოდის დამატება - მონაცემების დამატება სიის ბოლოს.

როგორც პარამეტრი, ეს მეთოდი იღებს ციფრულ მნიშვნელობას (ცვლადი xd), რომელიც უნდა იყოს შენახული სიის დამატებულ ელემენტში.

void cList::Add(int xd)

ასე იქმნება ახალი ელემენტი და დგინდება მისი რიცხვითი ველის მნიშვნელობა:

cElement *temp = newcElement;

temp->setdata(xd);

შემდეგ მოწმდება სიის ელემენტების რაოდენობა, თუ სია ცარიელია, მაშინ იქმნება სათაური ელემენტი, წინააღმდეგ შემთხვევაში იქმნება სიის „ჩვეულებრივი“ კომპონენტი;

თუ (დათვლა ==0)

temp->setref(NULL);

temp->setref(NULL);

p->setref(temp);

შეამჩნევთ, რომ ზემოაღნიშნული კონსტრუქცია იყენებს cElement კლასის setref მეთოდს, რომელიც აუცილებელია სიის შემდეგ ელემენტზე მითითების დასაყენებლად, წინააღმდეგ შემთხვევაში სია გაუქმდება, რამაც შეიძლება გამოიწვიოს მონაცემთა დაკარგვა და არასწორი პროგრამის მუშაობა.

როდესაც პირველად დაიწყებთ პროგრამას, ზემოთ აღწერილი მეთოდი გამოიყენება სიაში ელემენტების თანმიმდევრულად დასამატებლად, რომლითაც შეგიძლიათ იმუშაოთ ბრძანების ხაზში შეყვანის შესაჩერებლად, ციფრული მნიშვნელობის ნაცვლად უნდა შეიყვანოთ ბრძანება "stop". ელემენტი (იხ. სურათი 1).

სურათი 1 - სიაში ელემენტების დამატების პროცესი

"stop" ბრძანების შეყვანის შემდეგ, სია იბეჭდება და პროგრამა გადადის ბრძანების მოლოდინის რეჟიმში (იხ. სურათი 2).

სურათი 2 - დაბეჭდილი სია

ბეჭდვის მეთოდი - ბეჭდავს სიას.

დასაბეჭდად, მნიშვნელოვანია იცოდეთ სიის დასაწყისი, რათა თანმიმდევრულად დაბეჭდოთ სიის ყველა ელემენტის მნიშვნელობები, ამიტომ სიის „ხელმძღვანელის“ მითითება მითითებულია temp ცვლადში, რის შემდეგაც მოწმდება სიის არსებობა და გამოჩნდება შესაბამისი შეტყობინება, თუ ის არ არის დადასტურებული, თუ სია ცარიელი არ არის, მაშინ გამოჩნდება ეკრანზე:

void cList::Print()

ceElement * temp = head;

if (ტემპ == NULL) cout while (ტემპი != NULL)

temp = temp->getref();

Del მეთოდი - სიის საწყისი ელემენტის ამოღება.

საწყისი ელემენტის წასაშლელად, ჯერ უნდა გადაიტანოთ მითითება სიის შემდეგ კომპონენტზე, გახადოთ იგი პირველი ამ გზით და შემდეგ წაშალოთ საჭირო ელემენტი:

voidcList::Del()

ceElement * temp = head;

head = head->getref();

RemoveAll მეთოდი - შლის მთელ სიას.

ეს მეთოდი ეფუძნება ზემოხსენებულს და შედგება სიის საწყისი ელემენტების თანმიმდევრული წაშლისგან, სანამ მთელი სია არ წაიშლება.

void cList::RemoveAll()

ხოლო (ecount!=0)

ამ მეთოდის გასაშვებად, მენიუში უნდა შეიყვანოთ ბრძანება „dellist“ სიასთან მუშაობისთვის (იხ. სურათი 3).

სურათი 3 - ბრძანების შეყვანა სიის გასასუფთავებლად

და თუ მომხმარებელი ნამდვილად დარწმუნებულია თავის ქმედებებში, მან უნდა მიიღოს პროგრამის შეთავაზება, რის შემდეგაც მთელი სია წაიშლება (იხ. სურათი 4).

სურათი 4 - ცარიელი სია

ამოღების მეთოდი - შლის კონკრეტული სიის ელემენტს.

წინასთან შედარებით ნაკლებად რადიკალური მეთოდი. სიის მხოლოდ ერთი ელემენტი, რომელიც მითითებულია პარამეტრად, წაიშლება. ეს ხდება შემდეგნაირად: პროგრამა ჯერ ამოწმებს შეყვანილი პარამეტრის სისწორეს, თუ წაშლილი ელემენტის რაოდენობა ერთზე ნაკლებია ან მეტია სიის ელემენტების საერთო რაოდენობაზე, მაშინ გამოჩნდება შეცდომის შეტყობინება, მაგრამ თუ პროგრამას არ აქვს პრეტენზია შეყვანილ პარამეტრზე, შემდეგ მიმდებარედ მდებარე ელემენტების საჭირო ბმულები გადადის წაშლილთან, რათა სია დარჩეს ასოცირებული, რის შემდეგაც საჭირო ელემენტი წაიშლება.

void cList::Remove(int del)

ceElement *cur = ხელმძღვანელი, *de;

თუ ((del>=1) && (დელ

head = head->getref();

ხოლო (j!=del-1)

cur = cur->getref();

de=cur->getref();

cur->setref(de->getref());

coutsystem ("პაუზა");

ამ მეთოდის გასაშვებად, სიაში მუშაობის მენიუში უნდა შეიყვანოთ ბრძანება „წაშლა“. შემდეგ შეიყვანეთ წაშლილი ელემენტის ნომერი ან წაშლის გასაუქმებლად ბრძანება „უკან“ (იხ. სურათი 5).

სურათი 5 – სიის ელემენტის წაშლის პროცესი

მეოთხე ელემენტის ამოღების შემდეგ სია ასე გამოიყურება (იხ. სურათი 6).

სურათი 6 - სია ერთი ელემენტის ამოღების შემდეგ

ჩასმის მეთოდი - ჩასმულია ახალი ელემენტი სიაში მითითებულ ადგილას.

ეს მეთოდი პარამეტრებად იღებს: დასამატებელი ელემენტის პოზიციას და მის ციფრულ მნიშვნელობას. ახალი ელემენტი განთავსდება ზუსტად მითითებულ ადგილას, შესაბამისად, ამჟამინდელის მარჯვნივ განლაგებული ელემენტები ერთი პოზიციით გადაინაცვლებს. სიის დასაწყისში ახალი ელემენტის დამატებისას, თქვენ უბრალოდ უნდა გადაიტანოთ ბმული ამ ელემენტიდან შემდეგზე, რითაც დააკავშიროთ სია და მიუთითოთ ბმული საწყისი ელემენტთან. ოდნავ განსხვავებული ვითარება წარმოიქმნება ახალი ელემენტის დამატებისას ორ არსებულს შორის. ამისათვის გამოიყენეთ ციკლი, რათა მიაღწიოთ ელემენტის ჩასმას, შემდეგ დააკავშიროთ კომპონენტები, რომლებიც მდებარეობს მის მარჯვნივ და მარცხნივ ახალ ელემენტთან. ბოლოს და ბოლოს, რა უნდა გაკეთდეს, მაგალითად, თუ საჭიროა ჯაჭვის გახანგრძლივება: აუცილებელია მისი გახსნა, შემდეგ ჯაჭვის პირველ ნაწილზე მიმაგრება ახალი ბმული, იმავე რგოლზე მიმაგრება მეორე, მსგავსი რამ არის დანერგილი ამ მეთოდში. აღსანიშნავია, რომ თუ მიუთითებთ არასწორ პოზიციას დასამატებლად, რომელიც არის ერთზე ნაკლები ან მეტი ელემენტების საერთო რაოდენობაზე, პროგრამა აჩვენებს შესაბამის შეცდომის შეტყობინებას.

void cList::Insert (int pos, int val)

ceElement *cur = თავი;

cElement *temp = new ceElement;

temp->setdata(val);

თუ ((pos>=1) && (pos

temp->setref(head);

ხოლო (j!=pos-1)

cur = cur->getref();

p=cur->getref();

cur->setref(temp);

temp->setref(p);

coutsystem ("პაუზა");

ამ მეთოდის გასაშვებად, სიაში მუშაობის მენიუში უნდა შეიყვანოთ ბრძანება „ჩასმა“. შემდეგ შეიყვანეთ დასამატებელი ელემენტის პოზიცია და რიცხვითი მნიშვნელობა ან წაშლის გასაუქმებლად ბრძანება „უკან“ (იხ. სურათი 7).

სურათი 7 - ელემენტის ჩასმის პროცესი

სია 111 მნიშვნელობის ელემენტის მესამე პოზიციაზე დამატების შემდეგ, სია ასე გამოიყურება (იხ. სურათი 8).

სურათი 8 - სია ელემენტის დამატების შემდეგ

აღწერილობისას არაერთხელ იყო ნახსენები სიასთან მუშაობის მენიუ, გასათვალისწინებელია, რომ ეს მენიუ მნიშვნელოვნად უწყობს ხელს სიათან მუშაობას. მისი მოქმედების ალგორითმი შედგება იგივე მეთოდების ციკლურად გამოძახებაში, სიის დაბეჭდვაში, მაგალითად, გარკვეული ბრძანების შესვლამდე. ხელმისაწვდომი ბრძანებების სია შეგიძლიათ იხილოთ კონსოლში "დახმარების" შეყვანით (იხ. სურათი 9)

სურათი 9 - ხელმისაწვდომი ბრძანებები

მენიუს სრული კოდი წარმოდგენილია დანართში A.

1. ტესტირება

ხშირად მუშაობის დროს წარმოიქმნება სიტუაციები, რომლებიც დაკავშირებულია არასწორ მონაცემებთან, რამაც შეიძლება გამოიწვიოს პროგრამის მარცხი. რა თქმა უნდა, ყველა პროგრამამ უნდა განახორციელოს დაცვის ალგორითმები გამოუცდელი მომხმარებლებისგან, რაც თავიდან აიცილებს პროგრამის ავარიას. მოდით განვიხილოთ, როგორ ფუნქციონირებს ასეთი ალგორითმები შექმნილ პროგრამაში.

სიის საწყისი ჩანაწერი ხორციელდება ქვემოთ მოცემული კოდით:

თუ (ატოი(სს)!=NULL)

mylist.Add(atoi(ss));

სიაში ახალი ელემენტის დასამატებლად დამატების მეთოდის გამოძახებამდე, შეყვანილი სტრიქონი მოწმდება. atoi ფუნქცია გარდაქმნის სტრიქონის მნიშვნელობას ციფრულ მნიშვნელობად და აბრუნებს NULL-ს, თუ შეყვანის სტრიქონი არ არის რიცხვი. ამრიგად, შეყვანისას, ნებისმიერი სტრიქონი, რომელიც არ არის რიცხვი, იგნორირებული იქნება, გარდა იმ სტრიქონისა, რომელსაც აქვს შეყვანის შეჩერების ბრძანება (იხ. სურათი 10).

სურათი 10 - არასწორი მონაცემების შეყვანა

ასეთი მონაცემების შეყვანის შემდეგ სია ასე გამოიყურება (იხ. სურათი 11).

სურათი 11 – მიღებული სია

პროგრამა აგრძელებს სწორ მუშაობას მცდარი მონაცემების შეყვანის შემდეგაც. არასწორ მონაცემებთან გამკლავების მსგავსი მეთოდები გამოიყენება პროგრამაში არსებული სხვა შეყვანის ოპერაციებისთვის.

დასკვნა

ამ ნაშრომში იქნა მიღებული ცნებები აბსტრაქტული მონაცემთა ტიპების შესახებ, მათი წარმოდგენის პრინციპების შესახებ თანამედროვე პროგრამირების ენებში, კერძოდ C++-ში. უმეტეს თანამედროვე იმპერატიულ ენებში, ძირითადი კონცეფცია, რომელიც გამოიყენება პროგრამის კოდში აბსტრაქციების აღსაწერად, არის ობიექტზე ორიენტირებული მიდგომა. ობიექტზე ორიენტირებული პროგრამირება (OOP), ისევე როგორც პროგრამირების ADT მიდგომა, გარკვეულწილად არის იდეების განვითარება მოდულური პროგრამირების შესახებ. მოდულები არის პროგრამის კომპონენტები, რომლებსაც აქვთ ორი მნიშვნელოვანი თვისება:

მოდულები მალავენ განხორციელების დეტალებს საკუთარ თავში.

მოდულების ხელახლა გამოყენება შესაძლებელია პროგრამის სხვადასხვა ნაწილში.

დევიდ პარნასმა 1972 წელს თავის ნაშრომში კონცეპტუალიზა მოდულები, როგორც აბსტრაქტული მანქანები, რომლებიც ინახავს მდგომარეობას საკუთარ თავში და საშუალებას აძლევს ამ მდგომარეობის შეცვლას ოპერაციების კონკრეტული ნაკრების მეშვეობით. ეს კონცეფცია ფუნდამენტურია როგორც მონაცემთა აბსტრაქტული ტიპების, ასევე ობიექტზე ორიენტირებული პროგრამირების კონცეფციისთვის. პარალელების გავლება პარნასის შემოქმედებასა და OOP-ის თანამედროვე კონცეფციებს შორის, ადვილი შესამჩნევია კლასისა და მოდულის ცნებებს შორის ურთიერთობა.

ამ ნამუშევარში ხაზოვანი ცალმხრივად დაკავშირებული სიები, რომლებიც წარმოადგენს აბსტრაქტულ მონაცემთა ტიპს, წარმოდგენილია განვითარებული მოდულებით, რომელთა მდგომარეობებზე წვდომისათვის ასევე ხორციელდება სპეციალური ოპერაციები, რომლებსაც უწოდებენ მეთოდებს ობიექტზე ორიენტირებულ პროგრამირებაში.

ბიბლიოგრაფია

1. იან გრემი ობიექტზე ორიენტირებული მეთოდები. პრინციპები და პრაქტიკა = ობიექტზე ორიენტირებული მეთოდები: პრინციპები და პრაქტიკა. - მე-3 გამოცემა. - M.: “Williams”, 2004. - გვ. 880.

2. ენტონი სინტესი ასწავლე საკუთარ თავს ობიექტზე ორიენტირებული პროგრამირება 21 დღეში. - M.: “Williams”, 2002. - გვ. 672.

3. ბერტრანდ მაიერი პროგრამული სისტემების ობიექტზე ორიენტირებული დიზაინი + CD. საინფორმაციო ტექნოლოგიების ინტერნეტ უნივერსიტეტი - INTUIT.ru, რუსული გამოცემა, 2005 წ

4. ბილიგ ვ.ა. პროგრამირების საფუძვლები C#-ში. საინფორმაციო ტექნოლოგიების ინტერნეტ უნივერსიტეტი - INTUIT.ru, 2006 წ

5. "ახალი პროგრამირების ენები და მათი განვითარების ტენდენციები", უშკოვა ვ., 2005 წ.

6. Bjarne Stroustrup “The C++ Programming Language” სპეციალური გამოცემა ან მე-3 გამოცემა. ბინომი, ნეველის დიალექტი, ISBN 5-7989-0226-2, 5-7940-0064-3, 0-201-70073-5

7. Bjarne Stroustrup "C++ ენის დიზაინი და ევოლუცია". DMK-Press, სანკტ-პეტერბურგი, ISBN 5-469-01217-4, 0-201-54330-3

8. Bjarne Stroustrup "პროგრამირების პრინციპები და C++ გამოყენების პრაქტიკა." "I.D. Williams", 2011, ISBN 978-5-8459-1621-1 (რუსული)

9. Gradi Buch et al. „ობიექტზე ორიენტირებული ანალიზი და დიზაინი აპლიკაციის მაგალითებით“ მე-2 ან მე-3 გამოცემა. Binom, ნეველის დიალექტი, უილიამსი ISBN 978-5-8459-1401-9, 0-201-89551-X, 0-8053-5340-2, 5-7989-0067-3, 5-7940-0017-1

10. Scott Meyers "C++-ის ეფექტური გამოყენება. 50 რეკომენდაცია თქვენი პროგრამებისა და პროექტების გასაუმჯობესებლად" DMK, Peter, ISBN 0-201-92488-9, 5-93700-006-4, 5-469-01213-1

დანართი A

მენიუს კოდი

#include "cList.h"

#include "string.h"

namespace std-ის გამოყენებით;

coutwhile (strstr(ss,stop")==NULL)

თუ (ატოი(სს)!=NULL)

mylist.Add(atoi(ss));

სისტემა ("cls");

while (strstr(com"exit")==NULL)

coutmylist.Print();

if (strstr(com"help")!=NULL) com_ind=1;

if (strstr(com"add")!=NULL) com_ind=2;

if (strstr(com,insert")!=NULL) com_ind=3;

if (strstr(com"delete")!=NULL) com_ind=4;

if (strstr(com"dellist")!=NULL) com_ind=5;

შეცვლა (com_ind)

სისტემა ("cls");

სისტემა ("cls");

coutcoutcoutcoutcoutcoutcoutcom_ind=0;

if (strstr(ss,back")==NULL)

თუ (ატოი(სს)!=NULL)

mylist.Add(atoi(ss));

სისტემა ("cls");

//ელემენტების ჩასმა

if (strstr(ss,back")==NULL)

თუ (ატოი(სს)!=NULL)

სისტემა ("cls");

if (strstr(ss,back")==NULL)

თუ (ატოი(სს)!=NULL)

mylist.Insert(pos,atoi(ss));

სისტემა ("cls");

//ელემენტების წაშლა

if (strstr(ss,back")==NULL) განისაზღვრება მნიშვნელობების სიმრავლით მოცემულიდა ოპერაციების ნაკრები... დაკავშირებული სტრუქტურები მონაცემები – სიები. სტრუქტურა მონაცემებიარის ელემენტების კოლექცია მონაცემები, რომელთა შორის... კომპიუტერის მეხსიერებაში ე.წ აბსტრაქტულიან ლოგიკური. Უფრო ხშირად...

მრავალჯერადი ტიპი მონაცემები. კომპლექტი

ლექცია >> კომპიუტერული მეცნიერება, პროგრამირება

... ტიპიუბრალოების მსგავსი ტიპები მონაცემები. მრავალჯერადი ტიპებიაღწერილია განყოფილებაში ტიპები... RT შეიძლება აღწერილი იყოს. Აბსტრაქტულიგამოთვლითი სტრუქტურები, რომლებიც აღწერენ შეყვანას... სხვა შემთხვევებს ტიპებიყველა კომპონენტი სიაუნდა ემთხვეოდეს ტიპიფაილის კომპონენტები. ...

ობიექტზე ორიენტირებული მონაცემთა ბაზები მონაცემებიფუნქციონირებს განაწილებულ ქსელებში

რეზიუმე >> კომპიუტერული მეცნიერება

პროგრამირების ენების სფეროების განვითარება აბსტრაქტული ტიპები მონაცემებიდა ობიექტზე ორიენტირებული პროგრამირების ენები. ... ტიპები მონაცემები- სია და მასივი. თითოეული ლიტერალი ცალსახად იდენტიფიცირებულია მასივში არსებული ინდექსით და სერიული ნომრით სია ...

Აბსტრაქტულიინფორმაციის უსაფრთხოების მოდელები

რეზიუმე >> კომპიუტერული მეცნიერება

ინფორმაციის დაცვა…………………………………………………………..17 Აბსტრაქტულიინფორმაციული უსაფრთხოების მოდელები... არეგულირებს ურთიერთქმედებას ორივესთან ტიპები მონაცემები(სერტიფიკაციის წესები): ყველა... არსებულის სხვადასხვა ვარიაციები და დამატებები სია. უსაფრთხოების დონეები - გარკვეული...

კარგი დღე, ხაბრას მცხოვრებლებო!

შემდეგი პოსტი არის ჩემი აზრების შეჯამება კლასების ბუნებაზე და ADT-ზე. ამ აზრებს ავსებს საინტერესო ციტატები პროგრამული უზრუნველყოფის განვითარების გურუების წიგნებიდან

შესავალი

დავიწყოთ თანდათანობით ADT-ის განმარტებასთან მიახლოებით. ADT უპირველეს ყოვლისა არის მონაცემთა ტიპი, რაც ნიშნავს შემდეგს:
გარკვეული ხელმისაწვდომი ოპერაციების არსებობა ამ ტიპის ელემენტებზე;
ასევე მონაცემები, რომლების მიმართაც შესრულებულია ეს ოპერაციები (მნიშვნელობების დიაპაზონი).

რას ნიშნავს სიტყვა "აბსტრაქტული"? უპირველეს ყოვლისა, ცნება „აბსტრაქტულობა“ გულისხმობს ყურადღების ფოკუსირებას რაიმე მნიშვნელოვანზე და, ამავდროულად, ჩვენ უნდა გადავიტანოთ ყურადღება იმ დეტალებისგან, რომლებიც ამჟამად უმნიშვნელოა. აბსტრაქციის განმარტება კარგად არის გაშუქებული გრეიდი ბუშის წიგნში. განმარტება ასე გამოიყურება:

აბსტრაქცია არის საერთო თვისებების ობიექტების ერთობლიობის შერჩევა და გადაცემა, რომელიც განსაზღვრავს მათ კონცეპტუალურ საზღვრებს და განასხვავებს მათ ყველა სხვა ტიპის ობიექტისგან.
სხვა სიტყვებით რომ ვთქვათ, აბსტრაქცია გვაძლევს საშუალებას „მოვფინოთ ნათელი“ ჩვენთვის საჭირო ობიექტურ მონაცემებს და, ამავდროულად, „დაჩრდილოთ“ ის მონაცემები, რომლებიც ჩვენთვის არ არის მნიშვნელოვანი.

მაშ, რა მოხდება, თუ „მონაცემთა ტიპის“ და „აბსტრაქციის“ ცნებებს ერთმანეთთან აერთიანებთ? ჩვენ მივიღებთ მონაცემთა ტიპს, რომელიც გვაწვდის ოპერაციების გარკვეულ კომპლექტს, რომელიც უზრუნველყოფს ამ მონაცემთა ტიპის ობიექტების ქცევას და მონაცემთა ეს ტიპი ასევე მალავს მონაცემებს, რომელთა დახმარებითაც ეს ქცევა ხორციელდება. აქედან გამომდინარე, მივდივართ ADT-ის კონცეფციამდე:

ADT არის მონაცემთა ტიპი, რომელიც მალავს მის შიდა განხორციელებას კლიენტებისგან.
საოცარი ის არის, რომ აბსტრაქციის გამოყენებით, ADT გვაძლევს საშუალებას არ ვიფიქროთ დაბალი დონის განხორციელების დეტალებზე, არამედ ვიმუშაოთ რეალური სამყაროს მაღალი დონის არსთან (სტივ მაკკონელი).

მე მჯერა, რომ ADT-ის შემუშავებისას, თქვენ ჯერ უნდა განსაზღვროთ ინტერფეისი, რადგან ინტერფეისი არ უნდა იყოს დამოკიდებული ADT-ში მონაცემების შიდა წარმოდგენაზე. ინტერფეისის შემადგენელი ოპერაციების განსაზღვრის შემდეგ, თქვენ უნდა გაამახვილოთ ყურადღება იმ მონაცემებზე, რომლებიც განახორციელებენ ADT-ის მითითებულ ქცევას. შედეგად მივიღებთ მონაცემთა გარკვეულ სტრუქტურას – მექანიზმს, რომელიც გვაძლევს მონაცემთა შენახვისა და დამუშავების საშუალებას. ამავდროულად, ADT-ის სილამაზე იმაში მდგომარეობს, რომ თუ ჩვენ გვინდა შევცვალოთ მონაცემების შიდა წარმოდგენა, არ უნდა ვიაროთ მთელ პროგრამაში და შევცვალოთ კოდის ყველა ხაზი, რომელიც დამოკიდებულია მონაცემებზე, რომელთა შეცვლაც გვინდა. ADT აერთიანებს ამ მონაცემებს, რაც საშუალებას გაძლევთ შეცვალოთ ამ ტიპის ობიექტების მოქმედება და არა მთელი პროგრამა.

ATD-ის უპირატესობები

ADT-ის გამოყენებას ბევრი უპირატესობა აქვს (აღწერილი ყველა უპირატესობა შეგიძლიათ იხილოთ სტივ მაკკონელის წიგნში "Perfect Code"):

• განხორციელების დეტალების ინკაფსულაცია.
  ეს ნიშნავს, რომ მას შემდეგ რაც ჩვენ ჩავწერთ ADT-ის განხორციელების დეტალებს, კლიენტს მივაწვდით ინტერფეისს, რომლითაც მას შეუძლია ურთიერთქმედება ADT-თან. განხორციელების დეტალების შეცვლით, კლიენტების აღქმა ADT ოპერაციის შესახებ არ შეიცვლება.

• შემცირებული სირთულე.
  განხორციელების დეტალებისგან აბსტრაქციით, ჩვენ ფოკუსირებას ვაკეთებთ ინტერფეისზე, ანუ იმაზე, თუ რისი გაკეთება შეუძლია ADT-ს და არა იმაზე, თუ როგორ კეთდება ეს. უფრო მეტიც, ADT საშუალებას გვაძლევს ვიმუშაოთ რეალური სამყაროს არსთან.

• მონაცემთა გამოყენების ფარგლების შეზღუდვა.
  ADT-ის გამოყენებით შეგვიძლია დარწმუნებული ვიყოთ, რომ ADT-ის შიდა სტრუქტურის წარმომადგენლის მონაცემები არ იქნება დამოკიდებული კოდის სხვა ნაწილებზე. ამ შემთხვევაში რეალიზდება ADT-ის „დამოუკიდებლობა“.

• უაღრესად ინფორმაციული ინტერფეისი.
  ADT საშუალებას გაძლევთ წარმოადგინოთ მთლიანი ინტერფეისი დომენის ერთეულების თვალსაზრისით, რაც, ხედავთ, ზრდის ინტერფეისის წაკითხვასა და ინფორმატიულობას.

სტივ მაკკონელი რეკომენდაციას იძლევა დაბალი დონის მონაცემთა ტიპების წარმოდგენას, როგორიცაა სტეკი ან სია, როგორც ADT. ჰკითხეთ საკუთარ თავს, რას წარმოადგენს ეს სია. თუ იგი წარმოადგენს ბანკის თანამშრომელთა სიას, მაშინ განიხილეთ ATD, როგორც ბანკის თანამშრომლების სია.

ასე რომ, ჩვენ გავარკვიეთ რა არის ADT და დავასახელეთ მისი გამოყენების უპირატესობები. ახლა აღსანიშნავია, რომ OOP-ში კლასების შემუშავებისას, პირველ რიგში, უნდა იფიქროთ ADT-ზე. ამავდროულად, როგორც სტივ მაკკონელმა თქვა, თქვენ დაპროგრამებთ არა ენაზე, არამედ ენის დახმარებით. ანუ, თქვენ დაპროგრამებთ ენის საზღვრებს მიღმა, არ შემოიფარგლება მხოლოდ მასივების ან მონაცემთა მარტივი ტიპების თვალსაზრისით. ამის ნაცვლად, თქვენ იფიქრებთ აბსტრაქციის მაღალ დონეზე (მაგალითად, ცხრილების ან თანამშრომელთა სიების თვალსაზრისით). კლასი სხვა არაფერია, თუ არა დამატება და გზა ADT კონცეფციის განსახორციელებლად. ჩვენ შეგვიძლია კლასის წარმოდგენა ფორმულის სახითაც კი:
კლასი = ADT + მემკვიდრეობა + პოლიმორფიზმი.
ასე რომ, რატომ უნდა იფიქროთ ADT-ზე კლასების შემუშავებისას? რადგან, პირველ რიგში, ჩვენ უნდა გადავწყვიტოთ რომელი ოპერაციები შეადგენს მომავალი კლასის ინტერფეისს, რომელი მონაცემების დამალვა და რომელზე საჯარო წვდომის უზრუნველყოფა. ჩვენ უნდა ვიფიქროთ იმაზე, რომ ინტერფეისი გავხადოთ ძალიან ინფორმატიული, გავამარტივოთ კოდის ოპტიმიზაცია და ტესტირება და როგორ მივაწოდოთ სწორი აბსტრაქცია, რათა ვიფიქროთ რეალურ სამყაროზე და არა დაბალი დონის განხორციელების დეტალებზე. მიმაჩნია, რომ ADT-ის განსაზღვრის შემდეგ უნდა ვიფიქროთ მემკვიდრეობითობისა და პოლიმორფიზმის საკითხებზე.

აღსანიშნავია, რომ ADT-ის კონცეფციამ იპოვა ფართო გამოყენება OOP-ში, რადგან სწორედ ეს კონცეფციაა, რომელიც ავსებს OOP-ს და საშუალებას აძლევს შემცირდეს პროგრამების სირთულე პროგრამული უზრუნველყოფის მოთხოვნების სწრაფად ცვალებად სამყაროში.

ეს სტატია დავწერე იმისთვის, რომ დეველოპერების ყურადღება მივაპყრო ADT-ზე მუშაობის ხარისხისა და პროგრამული უზრუნველყოფის შემუშავების გასაუმჯობესებლად.

გამოყენებული წყაროები:

სტივ მაკკონელი - "სრულყოფილი კოდი";
რობერტ სეჯვიკი - "ალგორითმები ჯავაში".

აბსტრაქტული მონაცემთა ტიპი

აბსტრაქტული მონაცემთა ტიპი (ATD)- ეს არის მონაცემთა ტიპი, რომელიც უზრუნველყოფს ფუნქციების გარკვეულ კომპლექტს ამ ტიპის ელემენტებთან მუშაობისთვის, ასევე სპეციალური ფუნქციების გამოყენებით ამ ტიპის ელემენტების შექმნის შესაძლებლობას. ამ ტიპის მთელი შიდა სტრუქტურა იმალება პროგრამული უზრუნველყოფის შემქმნელისგან - ეს არის აბსტრაქციის არსი. აბსტრაქტული მონაცემთა ტიპი განსაზღვრავს ფუნქციების ერთობლიობას დამოუკიდებლად ტიპის კონკრეტული განხორციელებისგან მის მნიშვნელობებზე მუშაობისთვის. ADT-ების სპეციფიკურ განხორციელებას მონაცემთა სტრუქტურები ეწოდება.

პროგრამირებაში, აბსტრაქტული მონაცემთა ტიპები, როგორც წესი, წარმოდგენილია როგორც ინტერფეისი, რომელიც მალავს შესაბამის ტიპის დანერგვას. პროგრამისტები მუშაობენ აბსტრაქტულ მონაცემთა ტიპებთან ექსკლუზიურად მათი ინტერფეისის საშუალებით, რადგან მომავალში განხორციელება შეიძლება შეიცვალოს. ეს მიდგომა მიჰყვება ინკაფსულაციის პრინციპს ობიექტზე ორიენტირებულ პროგრამირებაში. ამ ტექნიკის სიძლიერე სწორედ განხორციელების დამალვაა. ვინაიდან მხოლოდ ინტერფეისი ქვეყნდება გარედან, მაშინ სანამ მონაცემთა სტრუქტურა მხარს უჭერს ამ ინტერფეისს, ყველა პროგრამა, რომელიც მუშაობს მოცემული აბსტრაქტული მონაცემთა ტიპის სტრუქტურასთან, გააგრძელებს მუშაობას. მონაცემთა სტრუქტურების შემქმნელები ცდილობენ, გარე ინტერფეისისა და ფუნქციების სემანტიკის შეცვლის გარეშე, თანდათანობით დახვეწონ განხორციელებები, გააუმჯობესონ ალგორითმები სიჩქარის, საიმედოობისა და გამოყენებული მეხსიერების თვალსაზრისით.

განსხვავება აბსტრაქტულ მონაცემთა ტიპებსა და მონაცემთა სტრუქტურებს შორის, რომლებიც ახორციელებენ აბსტრაქტულ ტიპებს, შეიძლება ილუსტრირებული იყოს შემდეგი მაგალითით. აბსტრაქტული სიის მონაცემთა ტიპი შეიძლება განხორციელდეს მასივის ან ხაზოვანი სიის გამოყენებით, მეხსიერების დინამიური განაწილების სხვადასხვა მეთოდების გამოყენებით. თუმცა, თითოეული იმპლემენტაცია განსაზღვრავს ფუნქციების ერთსა და იმავე კომპლექტს, რომელიც უნდა შეასრულოს იგივე (გამომავალში და არა სიჩქარეში) ყველა განხორციელებაში.

მონაცემთა აბსტრაქტული ტიპები საშუალებას გაძლევთ მიაღწიოთ პროგრამული პროდუქტების მოდულარობას და გქონდეთ ცალკეული მოდულის რამდენიმე ალტერნატიული ურთიერთშემცვლელი განხორციელება.

ADT მაგალითები

იხილეთ ასევე

ბმულები

• ლაპშინი V.A. მონაცემთა აბსტრაქტული ტიპები პროგრამირებაში

ფონდი ვიკიმედია. 2010 წელი.

ნახეთ, რა არის „აბსტრაქტული მონაცემთა ტიპი“ სხვა ლექსიკონებში:

აბსტრაქტული მონაცემთა ტიპი- მონაცემთა ტიპი (აბსტრაქტული კლასი), რომელიც განისაზღვრება მისი მეთოდებისა და თვისებების ჩამონათვალით, მათი კონკრეტული განხორციელების შექმნის გარეშე. თემები საინფორმაციო ტექნოლოგიები ზოგადად EN აბსტრაქტული მონაცემთა ტიპიADT ... ტექნიკური მთარგმნელის სახელმძღვანელო

პროგრამირების თეორიაში, ნებისმიერი ტიპი, რომლის მნიშვნელობები არის სხვა ტიპის მნიშვნელობები, რომლებიც "შეფუთულია" ალგებრული ტიპის კონსტრუქტორებით. სხვა სიტყვებით რომ ვთქვათ, მონაცემთა ალგებრულ ტიპს აქვს ტიპის კონსტრუქტორების ნაკრები, რომელთაგან თითოეული... ... ვიკიპედია

მთელი რიცხვი, მონაცემთა მთელი ტიპი (ინგლისური Integer), კომპიუტერულ მეცნიერებაში ერთ-ერთი უმარტივესი და ყველაზე გავრცელებული მონაცემთა ტიპი პროგრამირების ენებში. გამოიყენება მთელი რიცხვების წარმოსადგენად. ამ ტიპის რიცხვების ნაკრები არის... ... ვიკიპედია

ამ ტერმინს სხვა მნიშვნელობა აქვს, იხილეთ ნაკრები (მნიშვნელობები). კომპლექტი, ტიპი და მონაცემთა სტრუქტურა კომპიუტერულ მეცნიერებაში, არის მათემატიკური ობიექტების ნაკრების განხორციელება. მონაცემთა ტიპების ნაკრები საშუალებას გაძლევთ შეინახოთ მნიშვნელობების შეზღუდული რაოდენობა... ... ვიკიპედია

ზოგიერთი პროგრამირების ენა უზრუნველყოფს მონაცემთა სპეციალურ ტიპს რთული რიცხვებისთვის. ჩაშენებული ტიპის არსებობა ამარტივებს რთული რაოდენობით შენახვას და მათზე გამოთვლებს. შინაარსი 1 არითმეტიკა კომპლექსურ კომპლექსებზე 2 მხარდაჭერა ენებში ... ვიკიპედია

ამ ტერმინს სხვა მნიშვნელობა აქვს, იხილეთ ინდექსი. მაჩვენებლის დიაგრამა მაჩვენებელი (ინგლისური მაჩვენებელი) არის ცვლადი, რომლის მნიშვნელობების დიაპაზონი შედგება მეხსიერების უჯრედების მისამართებისგან და ნულოვანი მისამართის სპეციალური მნიშვნელობისგან... ... ვიკიპედია

ალგებრული მონაცემთა ტიპების ერთ-ერთი ტიპი, რომელიც ხასიათდება იმით, რომ მის კონსტრუქტორებს შეუძლიათ დააბრუნონ მნიშვნელობები, რომლებიც არ არის მათი ტიპი. ეს კონცეფცია დანერგილია პროგრამირების რამდენიმე ენაზე, კერძოდ ML და Haskell ენებზე და ... ... ვიკიპედიაში

თვისება არის აბსტრაქტული ტიპი კომპიუტერულ მეცნიერებაში, რომელიც გამოიყენება როგორც „მარტივი კონცეპტუალური მოდელი ობიექტზე ორიენტირებული პროგრამების სტრუქტურირებისთვის“. თვისებები მსგავსია მიქსინების, მაგრამ შეიძლება შეიცავდეს კლასის მეთოდების განმარტებებს... ... ვიკიპედია

ბინარული ხე, განშტოებული დაკავშირებული მონაცემთა სტრუქტურის მარტივი მაგალითი. მონაცემთა სტრუქტურა არის პროგრამის ერთეული, რომელიც საშუალებას გაძლევთ შეინახოთ ... ვიკიპედია

- (ზედა ტიპი) ტიპების თეორიაში, ხშირად აღინიშნება უბრალოდ ზედა ან "ფიქსირებული" სიმბოლო (⊤), უნივერსალური ტიპი, ანუ ტიპი, რომელიც შეიცავს ყველა შესაძლო ობიექტს სასურველი ტიპის სისტემაში. უმაღლეს ტიპს ზოგჯერ უწოდებენ... ... ვიკიპედიას

კარგი დღე, ხაბრას მცხოვრებლებო!

შემდეგი პოსტი არის ჩემი აზრების შეჯამება კლასების ბუნებაზე და ADT-ზე. ამ აზრებს ავსებს საინტერესო ციტატები პროგრამული უზრუნველყოფის განვითარების გურუების წიგნებიდან

შესავალი

დავიწყოთ თანდათანობით ADT-ის განმარტებასთან მიახლოებით. ADT უპირველეს ყოვლისა არის მონაცემთა ტიპი, რაც ნიშნავს შემდეგს:
გარკვეული ხელმისაწვდომი ოპერაციების არსებობა ამ ტიპის ელემენტებზე;
ასევე მონაცემები, რომლების მიმართაც შესრულებულია ეს ოპერაციები (მნიშვნელობების დიაპაზონი).

რას ნიშნავს სიტყვა "აბსტრაქტული"? უპირველეს ყოვლისა, ცნება „აბსტრაქტულობა“ გულისხმობს ყურადღების ფოკუსირებას რაიმე მნიშვნელოვანზე და, ამავდროულად, ჩვენ უნდა გადავიტანოთ ყურადღება იმ დეტალებისგან, რომლებიც ამჟამად უმნიშვნელოა. აბსტრაქციის განმარტება კარგად არის გაშუქებული გრეიდი ბუშის წიგნში. განმარტება ასე გამოიყურება:

აბსტრაქცია არის საერთო თვისებების ობიექტების ერთობლიობის შერჩევა და გადაცემა, რომელიც განსაზღვრავს მათ კონცეპტუალურ საზღვრებს და განასხვავებს მათ ყველა სხვა ტიპის ობიექტისგან.
სხვა სიტყვებით რომ ვთქვათ, აბსტრაქცია გვაძლევს საშუალებას „მოვფინოთ ნათელი“ ჩვენთვის საჭირო ობიექტურ მონაცემებს და, ამავდროულად, „დაჩრდილოთ“ ის მონაცემები, რომლებიც ჩვენთვის არ არის მნიშვნელოვანი.

მაშ, რა მოხდება, თუ „მონაცემთა ტიპის“ და „აბსტრაქციის“ ცნებებს ერთმანეთთან აერთიანებთ? ჩვენ მივიღებთ მონაცემთა ტიპს, რომელიც გვაწვდის ოპერაციების გარკვეულ კომპლექტს, რომელიც უზრუნველყოფს ამ მონაცემთა ტიპის ობიექტების ქცევას და მონაცემთა ეს ტიპი ასევე მალავს მონაცემებს, რომელთა დახმარებითაც ეს ქცევა ხორციელდება. აქედან გამომდინარე, მივდივართ ADT-ის კონცეფციამდე:

ADT არის მონაცემთა ტიპი, რომელიც მალავს მის შიდა განხორციელებას კლიენტებისგან.
საოცარი ის არის, რომ აბსტრაქციის გამოყენებით, ADT გვაძლევს საშუალებას არ ვიფიქროთ დაბალი დონის განხორციელების დეტალებზე, არამედ ვიმუშაოთ რეალური სამყაროს მაღალი დონის არსთან (სტივ მაკკონელი).

მე მჯერა, რომ ADT-ის შემუშავებისას, თქვენ ჯერ უნდა განსაზღვროთ ინტერფეისი, რადგან ინტერფეისი არ უნდა იყოს დამოკიდებული ADT-ში მონაცემების შიდა წარმოდგენაზე. ინტერფეისის შემადგენელი ოპერაციების განსაზღვრის შემდეგ, თქვენ უნდა გაამახვილოთ ყურადღება იმ მონაცემებზე, რომლებიც განახორციელებენ ADT-ის მითითებულ ქცევას. შედეგად მივიღებთ მონაცემთა გარკვეულ სტრუქტურას – მექანიზმს, რომელიც გვაძლევს მონაცემთა შენახვისა და დამუშავების საშუალებას. ამავდროულად, ADT-ის სილამაზე იმაში მდგომარეობს, რომ თუ ჩვენ გვინდა შევცვალოთ მონაცემების შიდა წარმოდგენა, არ უნდა ვიაროთ მთელ პროგრამაში და შევცვალოთ კოდის ყველა ხაზი, რომელიც დამოკიდებულია მონაცემებზე, რომელთა შეცვლაც გვინდა. ADT აერთიანებს ამ მონაცემებს, რაც საშუალებას გაძლევთ შეცვალოთ ამ ტიპის ობიექტების მოქმედება და არა მთელი პროგრამა.

ATD-ის უპირატესობები

ADT-ის გამოყენებას ბევრი უპირატესობა აქვს (აღწერილი ყველა უპირატესობა შეგიძლიათ იხილოთ სტივ მაკკონელის წიგნში "Perfect Code"):

• განხორციელების დეტალების ინკაფსულაცია.
  ეს ნიშნავს, რომ მას შემდეგ რაც ჩვენ ჩავწერთ ADT-ის განხორციელების დეტალებს, კლიენტს მივაწვდით ინტერფეისს, რომლითაც მას შეუძლია ურთიერთქმედება ADT-თან. განხორციელების დეტალების შეცვლით, კლიენტების აღქმა ADT ოპერაციის შესახებ არ შეიცვლება.

• შემცირებული სირთულე.
  განხორციელების დეტალებისგან აბსტრაქციით, ჩვენ ფოკუსირებას ვაკეთებთ ინტერფეისზე, ანუ იმაზე, თუ რისი გაკეთება შეუძლია ADT-ს და არა იმაზე, თუ როგორ კეთდება ეს. უფრო მეტიც, ADT საშუალებას გვაძლევს ვიმუშაოთ რეალური სამყაროს არსთან.

• მონაცემთა გამოყენების ფარგლების შეზღუდვა.
  ADT-ის გამოყენებით შეგვიძლია დარწმუნებული ვიყოთ, რომ ADT-ის შიდა სტრუქტურის წარმომადგენლის მონაცემები არ იქნება დამოკიდებული კოდის სხვა ნაწილებზე. ამ შემთხვევაში რეალიზდება ADT-ის „დამოუკიდებლობა“.

• უაღრესად ინფორმაციული ინტერფეისი.
  ADT საშუალებას გაძლევთ წარმოადგინოთ მთლიანი ინტერფეისი დომენის ერთეულების თვალსაზრისით, რაც, ხედავთ, ზრდის ინტერფეისის წაკითხვასა და ინფორმატიულობას.

სტივ მაკკონელი რეკომენდაციას იძლევა დაბალი დონის მონაცემთა ტიპების წარმოდგენას, როგორიცაა სტეკი ან სია, როგორც ADT. ჰკითხეთ საკუთარ თავს, რას წარმოადგენს ეს სია. თუ იგი წარმოადგენს ბანკის თანამშრომელთა სიას, მაშინ განიხილეთ ATD, როგორც ბანკის თანამშრომლების სია.

ასე რომ, ჩვენ გავარკვიეთ რა არის ADT და დავასახელეთ მისი გამოყენების უპირატესობები. ახლა აღსანიშნავია, რომ OOP-ში კლასების შემუშავებისას, პირველ რიგში, უნდა იფიქროთ ADT-ზე. ამავდროულად, როგორც სტივ მაკკონელმა თქვა, თქვენ დაპროგრამებთ არა ენაზე, არამედ ენის დახმარებით. ანუ, თქვენ დაპროგრამებთ ენის საზღვრებს მიღმა, არ შემოიფარგლება მხოლოდ მასივების ან მონაცემთა მარტივი ტიპების თვალსაზრისით. ამის ნაცვლად, თქვენ იფიქრებთ აბსტრაქციის მაღალ დონეზე (მაგალითად, ცხრილების ან თანამშრომელთა სიების თვალსაზრისით). კლასი სხვა არაფერია, თუ არა დამატება და გზა ADT კონცეფციის განსახორციელებლად. ჩვენ შეგვიძლია კლასის წარმოდგენა ფორმულის სახითაც კი:
კლასი = ADT + მემკვიდრეობა + პოლიმორფიზმი.
ასე რომ, რატომ უნდა იფიქროთ ADT-ზე კლასების შემუშავებისას? რადგან, პირველ რიგში, ჩვენ უნდა გადავწყვიტოთ რომელი ოპერაციები შეადგენს მომავალი კლასის ინტერფეისს, რომელი მონაცემების დამალვა და რომელზე საჯარო წვდომის უზრუნველყოფა. ჩვენ უნდა ვიფიქროთ იმაზე, რომ ინტერფეისი გავხადოთ ძალიან ინფორმატიული, გავამარტივოთ კოდის ოპტიმიზაცია და ტესტირება და როგორ მივაწოდოთ სწორი აბსტრაქცია, რათა ვიფიქროთ რეალურ სამყაროზე და არა დაბალი დონის განხორციელების დეტალებზე. მიმაჩნია, რომ ADT-ის განსაზღვრის შემდეგ უნდა ვიფიქროთ მემკვიდრეობითობისა და პოლიმორფიზმის საკითხებზე.

აღსანიშნავია, რომ ADT-ის კონცეფციამ იპოვა ფართო გამოყენება OOP-ში, რადგან სწორედ ეს კონცეფციაა, რომელიც ავსებს OOP-ს და საშუალებას აძლევს შემცირდეს პროგრამების სირთულე პროგრამული უზრუნველყოფის მოთხოვნების სწრაფად ცვალებად სამყაროში.

ეს სტატია დავწერე იმისთვის, რომ დეველოპერების ყურადღება მივაპყრო ADT-ზე მუშაობის ხარისხისა და პროგრამული უზრუნველყოფის შემუშავების გასაუმჯობესებლად.

გამოყენებული წყაროები:

სტივ მაკკონელი - "სრულყოფილი კოდი";
რობერტ სეჯვიკი - "ალგორითმები ჯავაში".