Как да направите шаблона за проектиране на Singleton в C ++: 9 стъпки

2024 Автор: John Day | [email protected]. Последно модифициран: 2024-01-30 07:52

Въведение:

Целта на това ръководство за инструкции е да научи потребителя как да внедри шаблона за проектиране на singleton в тяхната C ++ програма. По този начин този набор от инструкции също ще обясни на читателя защо елементите на сингълтона са такива, каквито са и как се обработва кодът. Знаейки това, ще помогне в бъдеще за отстраняване на грешки в бъдещите си сингълтъни. Какъв е моделът на единичен дизайн? Шаблонът за проектиране на singleton е модел на проектиране, при който кодерът създава клас, който може да бъде създаден само веднъж, публичните функции на класовете могат по принцип да бъдат достъпни навсякъде, при условие че сте включили #заглавния файл в други файлове, свързани с проекта.

Единичният модел за проектиране е задължителен модел за проектиране за всеки обектно-ориентиран програмист, софтуерни програмисти и програмисти за игри. Моделът за единичен дизайн също е един от най -лесните модели за кодиране. Изучаването му може да ви помогне да научите други, по -трудни дизайнерски модели в бъдеще. Също така може да ви помогне да опростите кода на програмата си по начини, които не смятате за възможни.

Докато трудността на шаблона за проектиране на сингълтон е лесна в сравнение с други модели на проектиране, този набор от инструкции има средна трудност. Това означава, че за да изпълните тези инструкции, ви препоръчваме да знаете основните и предварителни изисквания за синтаксис на C ++. Трябва също да знаете правилния етикет за кодиране на C ++ (т.е. Запазете променливите на класа частни, един клас на заглавен файл и т.н.). Трябва също да знаете как да освободите памет и как конструкторите и деструкторите работят в C ++.

Това ръководство ще отнеме средно около 10-15 минути.

Изисквания към материала:

-Компютър (може да бъде компютър или Mac), който може да работи с Visual Studios (всяка версия)

-Проста програма, създадена във Visual Studios, с която можете да тествате сингълтона си

Забележка: Шаблонът за проектиране на singleton може да се направи на всеки друг C ++, поддържащ IDE или кодиращ интерфейс, но за този набор от инструкции ще използваме Visual Studios Enterprise Edition.

Стъпка 1: Създайте своя клас, с заглавен файл и CPP файл

За да създадете тези два файла и класа наведнъж, отворете вашия проект / програма във Visual Studios, отидете на Explorer, щракнете с десния бутон и полето трябва да се покаже близо до курсора на мишката ви, намерете опцията „Добавяне“, задръжте курсора на мишката над него и вдясно трябва да се появи друго поле. В това поле искате да намерите опцията „New Item..“, щракнете върху нея и трябва да се появи прозорец, наподобяващ снимката 1.1 на изображението по -долу. В този прозорец искате да изберете „C ++ Class“и след това натиснете „Add“. Това ще отвори друг прозорец, който прилича на снимката 1.2. В този прозорец въвеждате името на вашия клас в полето „Име на класа“и Visual Studios автоматично ще кръсти действителния файл след името на класа. За целите на тази инструкция ще кръстим нашия клас „EngineDebugSingleton“, но това може да бъде всяко име, основано на букви. Сега можете да натиснете „OK“и да преминете към стъпка 2.

Забележка: Explorer Explorer и мястото, където файловете се съхраняват на вашия компютър, са отделни. Преместването или създаването на нещо в Explorer Explorer няма да премести или организира файловете във вашия File Explorer. Безопасен начин за организиране на вашите файлове от страна на File Explorer ще бъде премахване, но не и изтриване на конкретни файлове от Explorer Explorer, преместване на същите файлове във File Explorer на желаното място и след това връщане към Explorer Explorer, щракнете с десния бутон, намерете опцията „Добавяне“, след това „Съществуващ елемент“и намерете файловете, които сте преместили. Уверете се, че премествате и заглавния, и cpp файла.

Стъпка 2: Задайте конструктора на частен

С вашия новосъздаден CPP файл и заглавен файл, ако не се отвори автоматично, когато сте го създали, отидете в Explorer Explorer и кликнете и отворете „EngineDebugSingleton.h“. След това ще бъдете посрещнати с „EngineDebugSingleton ()“, конструктора по подразбиране на класа и „~ EngineDebugSingleton ()“деструктора на класа. За тази стъпка ще искаме да зададем конструктора на private, това означава, че тази функция е достъпна само за класа и нищо друго. С това няма да можете да направите променлива или да разпределите класа в паметта извън класа, само в заглавния файл на класовете и другите функции на класовете. Притежаването на конструктора за частен е ключът към шаблона за проектиране и начина на работа на сингълтоните. В бъдещите стъпки ще открием как се създава и осъществява достъп до сингълтън.

Сега класът трябва да изглежда така след преместването на конструктора на частен (Вижте свързаната снимка)

Стъпка 3: Задайте Destructor на Private

Както направихме с конструктора в

стъпка 2, за тази стъпка сега ще зададем деструктора на частен. Подобно на конструктора, нищо, освен самия клас, няма да може да изтрие всички променливи на класа от паметта.

След като завършите тази стъпка, класът трябва да изглежда така. (Вижте асоциирана снимка)

Стъпка 4: Създаване на променлива на статичен указател в Singleton

В тази стъпка ще създадем a

променлива на статичен указател от тип „EngineDebugSingleton*“. Това ще бъде променливата, която ще се използва, за да разпредели нашия сингълтън в паметта и ще го сочи за цялото време, в което нашият сингълтон е разпределен в паметта.

Ето как трябва да изглежда нашият заглавен файл след създаването на тази променлива

Стъпка 5: Създаване на функция за екземпляр

Сега искаме да направим екземпляр

функция. Функцията ще трябва да бъде статична функция и ще иска да върне препратка към нашия клас („EngineDebugSingleton &“). Извикахме нашата функция Instance (). В самата функция първо ще искаме да тестваме дали ptrInstance == nullptr (може да се съкрати до! PtrInstance), ако е nullptr, това означава, че singleton не е разпределен и в обхвата на оператора if, ние ще искате да разпределите, като направите ptrInstance = new EngineDebugSingleton (). Тук всъщност разпределяте сингълтона в паметта. След излизане от обхвата на оператора if, ние ще върнем това, което сочи ptrInstance, което се обозначава със синтаксиса „*ptrInstance“. Ние ще използваме тази функция силно, когато правим нашите статични публични функции, така че можем да проверим дали singleton е създаден и разпределен в паметта. По същество тази функция го прави така, че можете да имате само едно разпределение на класа и не повече.

Ето как трябва да изглежда нашият клас сега след създаването на функцията Instance (). Както можете да видите, всичко, което направихме, остана в частния раздел на класа, това ще се промени малко в следващите няколко стъпки.

Стъпка 6: Създаване на статични публични функции

След като направите функцията от

стъпка 5, можете да започнете да правите статични публични функции. Всяка публична функция трябва да има частна функция, която да върви заедно с нея, името на тази функция не може да бъде едно и също. Защо да направите функцията статична? Ние правим публичните функции статични, за да могат да бъдат достъпни без действителен обект. Така че вместо да правим нещо като „EngineDebugSingleObj-> SomeFunction ()“, ние правим „EngineDebugSingleton:: Some Function ()“. Това дава възможност за достъп до singleton по принцип навсякъде в кода, при условие, че #сте включили заглавния файл в конкретния файл на проекта, с който работите. С това можете също да създадете сингълтона чрез някоя от публичните му функции.

За нашите цели в тази стъпка създадохме две публични статични функции void, “add ()” и “subtract ()”. В частния раздел имаме още две функции, „PrivAdd ()“и „PrivSubtract ()“. Добавихме и променлива int, наречена „NumberOfThings“. Определението за тези функции ще влезе в CPP файла на нашите класове. За да накарате функцията лесно да влезе в CPP файла, маркирайте с курсора функцията, която трябва да има зелена линия под нея, и натиснете „Left ALT + ENTER“, това ще ви даде възможност да създадете дефиницията в клас, свързан CPP файл. Вижте Снимка 6.1, за да видите как трябва да изглежда заглавният файл и след като създадете всички дефиниции на функции, вашият CPP трябва да изглежда като Снимка 6.2, с изключение на това, че дефинициите на вашите функции няма да съдържат код.

Сега ще искате да добавите същия код, както на снимка 6.2, във вашите дефиниции на функции. Както беше посочено по -рано, нашите публични функции ще използват функцията Instance (), която ще върне това, към което сочи ptrInstance. Това ни позволява достъп до частните функции на нашия клас. С публичната функция на който и да е singleton трябва да извиквате само тази функция Instance. Единственото изключение от това е нашата функция за прекратяване.

Забележка: Точните публични и частни функции, показани в тази стъпка, не са необходими, можете да имате различни имена на функции и операции в частната функция, но за всеки тип публична функция трябва да имате частна функция, която да върви заедно с нея и публичната функция винаги трябва да използва, в нашия случай, функцията Instance ().

Стъпка 7: Създаване на функцията за прекратяване

Тъй като можем само да освободим нашия singleton от паметта в нашия клас, трябва да създадем статична публична функция. Тази функция ще извика delete на ptrInstance, който извиква деструктора на класа и след това ще искаме да върнем ptrInstance обратно на nullptr, така че да може да бъде разпределен отново, ако програмата ви не приключи. Също така ще искате да прекратите вашите Singletons, за да изчистите всяка разпределена памет, която сте разпределили в частни променливи на Singleton.

Стъпка 8: Задаване на PtrInstance на Nullptr

За да завършите сингълтона, искате да преминете към файла EngineDebugSingleton. CPP и в горната част на файла CPP, в нашия случай, въведете „EngineDebugSingleton* EngineDebugSingleton:: ptrInstance = nullptr.“

Това първоначално ще зададе ptrInstance на nullptr, така че когато за първи път преминете през функцията за екземпляр, на нашия клас ще бъде разрешено да бъде разпределен в паметта. Без него най -вероятно ще получите грешка, защото ще се опитвате да получите достъп до памет, която няма нищо разпределено за нея.

Стъпка 9: Тест и заключение

Сега ще искаме да тестваме нашия сингълтън, за да се уверим, че работи, това ще ни наложи да извикваме публичните функции, както е описано в стъпка 6 и препоръчваме да настроите точки на прекъсване, за да преминете през вашия код и да видите, че singleton работи като трябва да бъде. Нашата отправна точка ще бъде в main.cpp на нашия проект, а main.cpp сега изглежда като изображението по -долу.

Честито! Току -що завършихте първата си реализация на Singleton Design Pattern. С този модел на проектиране вече можете да рационализирате кода си по различни начини. Например, сега можете да създадете системи за управление, които да работят през времето на изпълнение на вашата програма, до които можете да получите достъп чрез статични функции навсякъде, където сте включили класа.

Последният ви заглавен файл трябва да изглежда като снимката 7.1. Свързаният CPP файл на вашия singleton трябва да изглежда като Снимка 6.2 с добавяне на, в горната част на файла, на кода, показан в стъпка 8. Тази инструкция ви предоставя проста структура на шаблона за проектиране на Singleton.

Съвети за отстраняване на неизправности:

Получаване на грешки, свързани с паметта?

Не забравяйте да се обърнете към стъпка 7 и стъпка 8, за да се уверите, че настройвате ptrInstance на nullptr.

Възниква ли безкраен цикъл?

Уверете се, че за публичните функции, в техните определения, вие извиквате частната функция, а не същата публична функция.

Обекти, разпределени в сингълтона, причиняващи течове на памет?

Уверете се, че извиквате функцията за прекратяване на вашия singleton, когато е подходящо в кода на програмата, и в деструктора на вашия singleton, не забравяйте да разпределите всички обекти, които са разпределени в паметта в обхвата на singleton кода.