როგორ გავაკეთოთ სინგლტონის დიზაინის ნიმუში C ++ - ში: 9 ნაბიჯი

2024 ავტორი: John Day | [email protected]. ბოლოს შეცვლილი: 2024-01-30 10:19

შესავალი:

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

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

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

ეს სახელმძღვანელო საშუალოდ 10-15 წუთს მიიღებს.

მატერიალური მოთხოვნები:

-კომპიუტერი (შეიძლება იყოს კომპიუტერი ან Mac), რომელსაც შეუძლია Visual Studios- ის გაშვება (ნებისმიერი ვერსია)

-მარტივი პროგრამა, რომელიც შეიქმნა Visual Studios– ში, რომლითაც შეგიძლიათ შეამოწმოთ თქვენი სინგლი

შენიშვნა: ერთი დიზაინის ნიმუში შეიძლება გაკეთდეს ნებისმიერ სხვა C ++ დამხმარე IDE- ს ან კოდირების ინტერფეისზე, მაგრამ ამ ინსტრუქციის ნაკრებისთვის ჩვენ ვიყენებთ Visual Studios Enterprise Edition- ს.

ნაბიჯი 1: შექმენით თქვენი კლასი, სათაურის ფაილით და CPP ფაილით

ამ ორი ფაილის და კლასის ერთდროულად შესაქმნელად გახსენით თქვენი პროექტი / პროგრამა Visual Studios– ში, გადადით გადაწყვეტილების გამომძიებელზე, დააწკაპუნეთ მარჯვენა ღილაკით და ყუთი უნდა გამოჩნდეს მაუსის კურსორის მახლობლად, იპოვეთ ვარიანტი „დამატება“მასზე და სხვა ყუთი უნდა გამოჩნდეს მარჯვნივ. ამ ყუთში გსურთ იპოვოთ ვარიანტი "ახალი პუნქტი..", დააწკაპუნეთ მასზე და გამოჩნდება ფანჯარა, რომელიც წააგავს ქვემოთ მოცემულ ფოტოს 1.1 სურათს. ამ ფანჯარაში გსურთ აირჩიოთ "C ++ კლასი" და შემდეგ დააჭირეთ ღილაკს "დამატება". ეს გახსნის სხვა ფანჯარას, რომელიც წააგავს ფოტო 1.2 სურათს. ამ ფანჯარაში თქვენ ჩაწერეთ თქვენი კლასის სახელი "კლასის სახელი" ველში და Visual Studios ავტომატურად ასახელებს რეალურ ფაილს კლასის სახელის მიხედვით. ამ ინსტრუქციის მიზნით, ჩვენ ვაპირებთ ჩვენს კლასს დავარქვათ "EngineDebugSingleton", მაგრამ ეს შეიძლება იყოს ნებისმიერი ასოზე დაფუძნებული სახელი. ახლა თქვენ შეგიძლიათ დააჭიროთ ღილაკს "OK" და გააგრძელოთ ნაბიჯი 2.

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

ნაბიჯი 2: დააყენეთ კონსტრუქტორი პირადი

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

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

ნაბიჯი 3: დესტრუქტორი დააყენეთ პირადი

როგორც ჩვენ გავაკეთეთ კონსტრუქტორთან ერთად

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

კლასი ახლა ასე უნდა გამოიყურებოდეს ამ ნაბიჯის დასრულების შემდეგ. (იხილეთ ასოცირებული ფოტო)

ნაბიჯი 4: შექმენით სტატიკური მაჩვენებლის ცვლადი სინგლტონში

ამ ეტაპზე ჩვენ შევქმნით ა

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

ასე უნდა გამოიყურებოდეს ჩვენი სათაურის ფაილი ამ ცვლადის შექმნის შემდეგ

ნაბიჯი 5: ინსტანციის ფუნქციის შექმნა

ჩვენ ახლა გვინდა მაგალითი გავაკეთოთ

ფუნქცია. ფუნქცია უნდა იყოს სტატიკური ფუნქცია და მოისურვებს ჩვენს კლასში მითითების დაბრუნებას ("EngineDebugSingleton &"). ჩვენ დავურეკეთ ჩვენს ფუნქციას Instance (). თავად ფუნქციაში, ჩვენ გვსურს პირველად შევამოწმოთ თუ არა ptrInstance == nullptr (შეიძლება შემოკლდეს! მინდა გამოვყო ptrInstance = new EngineDebugSingleton (). ეს არის ის, სადაც თქვენ რეალურად გამოყოფთ სინგლს მეხსიერებაში. If განცხადების ფარგლებიდან გასვლის შემდეგ, ჩვენ დავუბრუნდებით იმას, რასაც ptrInstance მიუთითებს, რომელიც აღინიშნება სინტაქსით "*ptrInstance". ჩვენ ვიყენებთ ამ ფუნქციას მძიმედ ჩვენი სტატიკური საზოგადოებრივი ფუნქციების შექმნისას, ასე რომ ჩვენ შეგვიძლია შევამოწმოთ, შეიქმნა თუ არა სინგლი მეხსიერებაზე. არსებითად, ეს ფუნქცია ქმნის მას, ასე რომ თქვენ შეგიძლიათ გქონდეთ კლასის მხოლოდ ერთი გამოყოფა და არა მეტი.

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

ნაბიჯი 6: სტატიკური საზოგადოებრივი ფუნქციების შექმნა

მას შემდეგ რაც თქვენ გააკეთეთ ფუნქცია

ნაბიჯი 5, თქვენ შეგიძლიათ დაიწყოთ სტატიკური საზოგადოებრივი ფუნქციების შექმნა. ყველა საჯარო ფუნქციას უნდა ჰქონდეს პირადი ფუნქცია მასთან ერთად, ამ ფუნქციის სახელი არ შეიძლება იყოს იგივე. რატომ არის ფუნქცია სტატიკური? ჩვენ ვაქცევთ საზოგადოებრივ ფუნქციებს სტატიკურად, რათა მათზე წვდომა იყოს რეალური ობიექტის გარეშე. ასე რომ, იმის ნაცვლად, რომ გავაკეთოთ მსგავსი რამ "EngineDebugSingleObj-> SomeFunction ()", ჩვენ ვაკეთებთ "EngineDebugSingleton:: ზოგიერთი ფუნქცია ()". ეს შესაძლებელს ხდის სინგლეთზე წვდომას ძირითადად სადმე კოდში, იმ პირობით, თუ თქვენ #ჩართეთ სათაურის ფაილი კონკრეტულ პროექტის ფაილში, რომელთანაც მუშაობთ. ამასთან, თქვენ ასევე შეგიძლიათ შექმნათ სინგლიტი მისი ნებისმიერი საზოგადოებრივი ფუნქციის საშუალებით.

ჩვენი მიზნებისათვის ამ ეტაპზე ჩვენ შევქმენით ორი საჯარო სტატიკური ბათილი ფუნქცია, "დამატება ()" და "გამოკლება ()". კერძო განყოფილებაში ჩვენ გვაქვს კიდევ ორი ფუნქცია, "PrivAdd ()" და "PrivSubtract ()". ჩვენ ასევე დავამატეთ int ცვლადი სახელწოდებით "NumberOfThings". ამ ფუნქციების განმარტება შევა ჩვენი კლასების CPP ფაილში. იმისათვის, რომ ფუნქცია ადვილად მოხვდეს CPP ფაილში, თქვენ კურსორით მონიშნავთ ფუნქციას, რომელსაც უნდა ჰქონდეს მწვანე ხაზი და დააჭირეთ ღილაკს "Left ALT + ENTER", ის მოგცემთ შესაძლებლობას შექმნათ განმარტება კლასების დაკავშირებული CPP ფაილი. იხილეთ ფოტო 6.1, რომ ნახოთ როგორ უნდა იყოს სათაურის ფაილი და მას შემდეგ რაც შექმნით ყველა ფუნქციის განსაზღვრებას, თქვენი CPP უნდა გამოიყურებოდეს როგორც ფოტო 6.2 გარდა იმისა, რომ თქვენი ფუნქციის განმარტებებს არ ექნებათ კოდი.

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

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

ნაბიჯი 7: შეწყვეტის ფუნქციის შექმნა

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

ნაბიჯი 8: დააყენეთ PtrInstance Nullptr– ზე

თქვენი სინგლის დასასრულებლად, თქვენ უნდა გადადით EngineDebugSingleton. CPP ფაილზე და CPP ფაილის თავზე, ჩვენს მაგალითში, ჩაწერეთ „EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr.“

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

ნაბიჯი 9: ტესტი და დასკვნა

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

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

თქვენი სათაურის ბოლო ფაილი უნდა გამოიყურებოდეს ფოტო 7.1 -ში. თქვენი სინგლტონის ასოცირებული CPP ფაილი უნდა გამოიყურებოდეს ფოტო 6.2 -ით, ფაილის ზედა ნაწილში დამატებულია მე -8 ნაბიჯში ნაჩვენები კოდი. ეს ინსტრუქცია მოგაწვდით Singleton დიზაინის ნიმუშის მარტივ სტრუქტურას.

რჩევების აღმოფხვრა:

მიიღეთ მეხსიერებასთან დაკავშირებული შეცდომები?

დარწმუნდით, რომ მიმართავთ მე –7 საფეხურს და მე –8 საფეხურს, რათა დარწმუნდეთ, რომ თქვენ ადგენთ ptrInstance– ს nullptr– ზე.

ხდება უსასრულო მარყუჟი?

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

მეხსიერების გაჟონვის გამომწვევი ერთეულის ფარგლებში გამოყოფილი ობიექტები?

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