მონაცემთა სტრუქტურის ერთ-ერთი სახეობა, რომელიც დღეს ფართოდ გამოიყენება განაცხადის პროგრამირებაში, არის სტეკი. მისი თავისებურებაა ელემენტების ორგანიზების პრინციპი, რომელშიც მათი დამატება და ამოღება შესაძლებელია მხოლოდ ერთ ჯერზე და მხოლოდ "ზემოდან", ანუ LIFO პრინციპის შესაბამისად. მაგრამ ზოგჯერ საჭიროა მთელი დასტის ერთდროულად გარკვევა.
აუცილებელია
- - ტექსტური რედაქტორი ან IDE;
- - თარჯიმანი გამოყენებული პროგრამირების ენიდან.
ინსტრუქციები
Ნაბიჯი 1
გამოიყენეთ მეთოდები დასტის ობიექტებზე, რომლებიც სპეციალურად შექმნილია დასტის გასასუფთავებლად. ისინი წარმოდგენილია სხვადასხვა ბიბლიოთეკის და შესაბამისი ჩარჩოების შესაბამის კლასებში. მაგალითად,. NET Stack კლასს აქვს Clear მეთოდი. მისი გამოყენების მაგალითი C # -ში შეიძლება ასე გამოიყურებოდეს:
დასტა oStack = ახალი დასტა (); // დასტის ობიექტის შექმნა
oStack. Push ("000"); // დასტის შევსება
oStack. Push ("111");
oStack. Clear (); // დასტის გასუფთავება
ნაბიჯი 2
გაწმენდისთვის ასევე შეიძლება გამოყენებულ იქნას კონტეინერების კლასების ელემენტების რაოდენობის შეცვლის მეთოდები, რომლებზეც ხშირად აგებულია დასტის კლასების ფუნქციონირება. თქვენ უბრალოდ უნდა შეამციროთ ელემენტების ამჟამინდელი რაოდენობა ნულამდე. მაგალითად, Qt შაბლონის კლასი QStack მემკვიდრეობით იღებს QVector შაბლონის კლასიდან, რომელსაც აქვს ზომის შეცვლის მეთოდი. მისი გამოყენების მაგალითი შეიძლება იყოს ასეთი:
QStack oStack; // დასტის ობიექტის დეკლარაცია
for (int i = 0; i <10; i ++) oStack.push (i); // დასტის შევსება
oStack.resize (0); // დასტის გასუფთავება
ნაბიჯი 3
დასტის ობიექტის გასუფთავება ჩვეულებრივ შეიძლება მოხდეს დავალების ოპერატორის საშუალებით, რაც ხშირად ხორციელდება შესაბამის კლასებში. ამისათვის დასტის გასუფთავების ობიექტს უნდა მიენიჭოს ნაგულისხმევი კონსტრუქტორის მიერ შექმნილი დროებითი ობიექტი. მაგალითად, C ++ სტანდარტული ბიბლიოთეკის სტეკის შაბლონური კლასი, რომელიც არის კონტეინერის შაბლონირებული კლასების ადაპტერი, არ აქვს რიცხვის თვითნებური შეცვლის ან ყველა ელემენტის ამოღების მეთოდები. ამის გასუფთავება შეგიძლიათ ასე:
std:: stack <int, std:: list> oStack; // დასტის ობიექტის დეკლარაცია
for (int i = 0; i <10; i ++) oStack.push (i); // დასტის შევსება
oStack = std:: დასტა
ნაბიჯი 4
დასტის ობიექტის გასუფთავება ასლის კონსტრუქტორის გამოძახებით ახალი ოპერატორის გამოყენებით, ნაგულისხმევი კონსტრუქტორის მიერ შექმნილი ობიექტის არგუმენტით:
std:: stack <int, std:: list> oStack; // დასტის ობიექტის დეკლარაცია
for (int i = 0; i <10; i ++) oStack.push (i); // დასტის შევსება
ახალი std:: დასტა
ნაბიჯი 5
დასტის გასუფთავება შესაძლებელია ყველა ელემენტის თანმიმდევრული მიღებით შესაბამისი მეთოდების გამოყენებით:
std:: stack <int, std:: list> oStack; // დასტის ობიექტის დეკლარაცია
for (int i = 0; i <10; i ++) oStack.push (i); // დასტის შევსება
while (! oStack.empty ()) oStack.pop (); // დასტის გასუფთავება
ამასთან, ამ მიდგომას აქვს დროის სირთულე, რაც ხაზოვანი დამოკიდებულია დასტის ელემენტების რაოდენობაზე. ამიტომ, მისი გამოყენება არ არის რაციონალური.
