Paano Gawin ang pattern ng Disenyo ng Singleton sa C ++: 9 Mga Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:13

Panimula:

Ang layunin ng gabay sa pagtuturo na ito ay upang turuan ang gumagamit sa kung paano ipatupad ang pattern ng disenyo ng singleton sa kanilang programa sa C ++. Sa paggawa nito, ipapaliwanag din ng hanay ng tagubilin na ito sa mambabasa kung bakit ang mga elemento ng isang singleton ay ang paraan ng mga ito at kung paano pinoproseso ang code. Alam ito, makakatulong sa hinaharap sa pag-debug ng iyong hinaharap na mga singleton. Ano ang pattern ng disenyo ng singleton? Ang pattern ng disenyo ng singleton ay isang pattern ng disenyo kung saan ang coder ay lumilikha ng isang klase na maaari lamang ma-instayate nang isang beses, ang mga pampublikong pag-andar ng mga klase ay maaaring ma-access kahit saan, sa kondisyon na # isinama mo ang header file sa iba pang mga file na nauugnay sa proyekto.

Ang pattern ng disenyo ng singleton ay dapat malaman ang disenyo ng pattern para sa anumang programmer na nakatuon sa object, programmers ng software, at programmers ng laro. Ang pattern ng disenyo ng singleton ay isa rin sa pinakamadaling mga pattern ng disenyo ng pag-coding doon. Ang pag-aaral nito ay makakatulong sa iyo na matuto nang iba, mas mahirap, mga pattern ng disenyo sa hinaharap. Matutulungan ka rin nito na streamline ang code ng iyong programa sa mga paraang hindi mo inaakalang posible.

Habang ang kahirapan ng pattern ng disenyo ng singleton ay madali kung ihahambing sa iba pang mga pattern ng disenyo, ang hanay ng pagtuturo na ito ay may katamtamang kahirapan. Nangangahulugan ito na upang gawin ang mga tagubiling ito, inirerekumenda namin na malaman mo ang pangunahing at isulong ang mga kinakailangan sa syntax ng C ++. Dapat mo ring malaman ang wastong pag-uugali ng pag-coding ng C ++ (ibig sabihin, panatilihing pribado ang mga variable ng klase, isang klase bawat file ng header atbp.). Dapat mo ring malaman kung paano magbakante ng memorya at kung paano gumagana ang mga konstruktor at destructor sa C ++.

Ang gabay sa pagtuturo na ito ay tatagal ng average sa paligid ng 10-15 minuto.

Mga Kinakailangan sa Materyal:

-Isang computer (maaaring maging PC o Mac) na may kakayahang magpatakbo ng Visual Studios (anumang bersyon)

-Isang simpleng programa, nilikha sa Visual Studios, na maaari mong subukan ang iyong singleton

Tandaan: Ang pattern ng disenyo ng singleton ay maaaring gawin sa anumang iba pang C ++ na sumusuporta sa IDE o interface ng coding, ngunit para sa itinakdang tagubilin na ito, gagamitin namin ang Visual Studios Enterprise Edition.

Hakbang 1: Lumikha ng Iyong Klase, Gamit ang Header File at CPP File

Upang likhain ang dalawang file na ito at ang klase nang sabay-sabay, buksan ang iyong proyekto / programa sa Visual Studios, pumunta sa solusyon ng explorer, pag-click sa kanan, at isang kahon ay dapat ipakita malapit sa iyong mouse cursor, hanapin ang opsyong "Magdagdag", mag-hover sa ibabaw nito, at ang isa pang kahon ay dapat na lumitaw sa kanan. Sa kahon na ito, nais mong hanapin ang pagpipiliang "Bagong Item..", i-click ito at isang window, na kahawig ng larawan na 1.1 na imahe sa ibaba, dapat lilitaw. Sa window na ito nais mong piliin ang "C ++ Class" at pagkatapos ay pindutin ang "Add". Bubuksan nito ang isa pang window na kahawig ng larawan na larawan 1.2. Sa window na ito, nagta-type ka sa pangalan ng iyong klase sa patlang na "Pangalan ng Klase" at awtomatikong pangalanan ng Visual Studios ang aktwal na file pagkatapos ng pangalan ng klase. Para sa hangaring ito ng tagubilin, papangalanan namin ang aming klase ng "EngineDebugSingleton", ngunit maaari itong maging anumang pangalan na batay sa liham. Maaari mo na ngayong pindutin ang "OK" at magpatuloy sa hakbang 2.

Tandaan: Ang explorer ng solusyon at kung saan itinatago ang mga file sa iyong computer ay magkahiwalay. Ang paglipat o paglikha ng anumang bagay sa explorer ng solusyon ay hindi lilipat o ayusin ang mga file sa loob ng iyong explorer ng OS file. Ang isang ligtas na paraan upang ayusin ang iyong mga file sa panig ng explorer ng file ay aalisin, ngunit hindi tatanggalin ang mga tukoy na file mula sa solusyon sa explorer, ilipat ang parehong mga file sa file explorer sa nais na lokasyon at pagkatapos ay bumalik sa solusyon ng explorer, i-right click, hanapin ang opsyong "Magdagdag", pagkatapos ay hanapin ang "Umiiral na Item" at hanapin ang mga file na iyong inilipat. Tiyaking ilipat mo ang parehong file ng header at cpp.

Hakbang 2: Itakda sa Pribado ang Tagatayo

Sa iyong bagong nilikha na CPP file at header file, kung hindi ito awtomatikong nagbukas noong nilikha mo ito, pumunta sa explorer ng solusyon at i-click at buksan ang "EngineDebugSingleton.h". Sasalubungin ka pagkatapos ng isang "EngineDebugSingleton ()", ang tagabuo ng default na klase at "~ EngineDebugSingleton ()" na klase na destructor. Para sa hakbang na ito, gugustuhin naming itakda ang tagapagbuo sa pribado, nangangahulugan ito na ang pagpapaandar na ito ay magagamit lamang sa klase at wala nang iba pa. Sa pamamagitan nito, hindi ka makakagawa ng isang variable o ilalaan ang klase sa memorya sa labas ng klase, sa header file lamang ng mga klase at iba pang mga pagpapaandar ng mga klase. Ang pagkakaroon ng pribadong konstruktor ay susi sa pattern ng disenyo at kung paano gumana ang mga singleton. Matutuklasan namin sa hinaharap na mga hakbang kung paano ang isang singleton ay nai-instay at na-access.

Dapat ganito ang hitsura ng klase pagkatapos ilipat ang konstruktor sa pribado (Tingnan ang nauugnay na larawan)

Hakbang 3: Itakda ang Destructor sa Pribado

Tulad ng ginawa namin sa taga-buo sa

Hakbang 2, para sa hakbang na ito, itatakda namin ngayon sa pribado ang destructor. Tulad ng tagatayo, wala, maliban sa klase mismo, ang makakapagtanggal ng anumang mga variable ng klase mula sa memorya.

Dapat ganito ang hitsura ng klase pagkatapos makumpleto ang hakbang na ito. (Tingnan ang Naiugnay na larawan)

Hakbang 4: Lumilikha ng isang Static Pointer Variable sa Singleton

Sa hakbang na ito, lilikha kami ng a

variable na static pointer ng uri ng "EngineDebugSingleton *". Ito ang magiging variable na gagamitin na ilaan ang aming singleton sa memorya at ituturo ito sa buong oras na inilalaan ang aming singleton sa memorya.

Ito ang hitsura ng aming header file pagkatapos likhain ang variable na ito

Hakbang 5: Lumilikha ng isang Instance Function

Nais naming gumawa ng isang halimbawa

pagpapaandar Ang pagpapaandar ay kailangang maging isang static na pag-andar at nais na bumalik ng isang sanggunian sa aming klase ("EngineDebugSingleton &"). Tinawag namin ang aming pagpapaandar na Instance (). Sa pagpapaandar mismo, nais naming unang subukan kung ptrInstance == nullptr (maaaring paikliin sa! PtrInstance), kung ito ay nullptr, nangangahulugan ito na ang singleton ay hindi inilalaan at sa saklaw ng kung pahayag, gagawin namin nais na ilaan sa pamamagitan ng paggawa ng ptrInstance = bagong EngineDebugSingleton (). Dito mo talaga inilalaan ang singleton sa memorya. Matapos lumabas ng saklaw ng kung pahayag, ibabalik namin kung ano ang itinuturo ng ptrInstance, na kung saan ay ipinahiwatig ng syntax na "* ptrInstance". Gagamitin namin nang labis ang pagpapaandar na ito kapag ginagawa ang aming static na mga pampublikong pag-andar, kaya maaari naming suriin upang makita kung ang singleton ay nilikha at inilalaan sa memorya. Sa esensya, ginagawa ng pagpapaandar na ito upang magkaroon ka lamang ng isang paglalaan ng klase at wala na.

Ito ang dapat magmukhang klase ngayon pagkatapos malikha ang pagpapaandar na Instance (). Tulad ng nakikita mo, ang lahat ng aming nagawa ay nanatili sa pribadong seksyon ng klase, magbabago ito nang kaunti sa mga susunod na hakbang.

Hakbang 6: Lumilikha ng Static Public Function

Matapos mong magawa ang pagpapaandar mula sa

Hakbang 5, maaari kang magsimulang gumawa ng mga static na pagpapaandar ng publiko. Ang bawat pagpapaandar sa publiko ay dapat magkaroon ng isang pribadong pagpapaandar upang sumabay dito, ang pangalan ng pagpapaandar na ito ay hindi maaaring pareho. Bakit ginagawang Static ang pagpapaandar? Ginagawa naming static ang mga pagpapaandar ng publiko upang ma-access sila nang walang isang tunay na bagay. Kaya sa halip na gumawa ng isang bagay tulad ng "EngineDebugSingleObj-> SomeFunction ()", ginagawa namin ang "EngineDebugSingleton:: Some Function ()". Ginagawang posible para sa isang singleton na ma-access karaniwang sa kahit saan sa code, sa kondisyon na # isinama mo ang header file sa tukoy na file ng proyekto na iyong pinagtatrabahuhan. Sa pamamagitan nito, maaari mo ring likhain ang singleton sa pamamagitan ng alinman sa mga pampublikong pagpapaandar nito.

Para sa aming mga layunin sa hakbang na ito lumikha kami ng dalawang pampublikong static na walang bisa na mga pag-andar, "idagdag ()" at "ibawas ()". Sa pribadong seksyon, dalawa pa kaming pagpapaandar, "PrivAdd ()" at "PrivSubtract ()". Nagdagdag din kami ng isang int variable na tinatawag na "NumberOfThings". Ang kahulugan para sa mga pagpapaandar na ito ay mapupunta sa file ng CPP ng aming mga klase. Upang madaling mapunta ang pagpapaandar sa file na CPP, i-highlight mo, gamit ang iyong cursor, ang pagpapaandar, na dapat magkaroon ng isang berdeng linya sa ilalim nito, at pindutin ang "Kaliwa ALT + ENTER", bibigyan ka nito ng pagpipiliang lumikha ng kahulugan sa nauugnay na CPP file ng mga klase. Tingnan ang Larawan 6.1 upang makita kung ano ang dapat magmukhang file ng header at pagkatapos mong likhain ang lahat ng mga kahulugan ng pagpapaandar, ang iyong CPP ay dapat magmukhang Larawan 6.2 maliban na ang iyong mga kahulugan ng pag-andar ay walang code sa kanila.

Gugustuhin mo ngayon na idagdag ang parehong code tulad ng sa Larawan 6.2 sa iyong mga kahulugan ng pag-andar. Tulad ng nakasaad nang mas maaga, ang aming mga pampublikong pag-andar ay gagamitin ang pag-andar ng Instance (), na magbabalik kung ano ang tinuturo ng ptrInstance. Pinapayagan kaming ma-access ang mga pribadong pag-andar ng aming klase. Sa pampublikong pagpapaandar ng singleton, dapat mo lang tawagan ang pagpapaandar na Instance na iyon. Ang tanging pagbubukod dito ay ang aming Pagwawakas ng pagpapaandar.

Tandaan: Ang eksaktong pampubliko at pribadong pag-andar na ipinapakita sa hakbang na ito ay hindi kinakailangan, maaari kang magkaroon ng iba't ibang mga pangalan ng pag-andar at pagpapatakbo sa pribadong pag-andar, ngunit para sa anumang uri ng pampublikong pag-andar, dapat kang magkaroon ng isang pribadong pag-andar upang sumabay dito at dapat laging gamitin ang pagpapaandar ng publiko, sa aming kaso, ang paggana ng Instance ().

Hakbang 7: Paglikha ng Tapusin na Pag-andar

Dahil mapapalitan lamang namin ang aming singleton mula sa memorya sa aming klase, dapat kaming lumikha ng isang static na pagpapaandar ng publiko. Tatawagan ng pagpapaandar na ito ang tanggalin sa ptrInstance, na tumatawag sa destructor ng klase at pagkatapos ay gugustuhin naming itakda ang ptrInstance pabalik sa nullptr upang maibigay ito muli kung hindi natapos ang iyong programa. Gusto mo ring wakasan ang iyong Singletons upang linisin ang anumang inilalaan na memorya na iyong inilalaan sa mga pribadong variable ng Singleton.

Hakbang 8: Pagtatakda ng PtrInstance sa Nullptr

Upang makumpleto ang iyong singleton, nais mong magtungo sa EngineDebugSingleton. CPP file at sa tuktok ng file na CPP, sa aming halimbawa, i-type ang "EngineDebugSingleton * EngineDebugSingleton:: ptrInstance = nullptr."

Ang paggawa nito ay itatakda sa una ang ptrInstance sa nullptr, kaya't kapag ka dumaan sa pag-andar ng halimbawa sa unang pagkakataon, papayagan ang aming klase na mailaan sa memorya. Kung wala ito, malamang na makakuha ka ng isang error dahil susubukan mong i-access ang memorya na walang inilaan dito.

Hakbang 9: Pagsubok at Konklusyon

Gusto naming subukan ngayon na ang aming singleton upang matiyak na gumagana ito, sangkot kami sa pagtawag sa mga pampublikong pag-andar tulad ng inilarawan sa hakbang 6 at inirerekumenda namin na mag-set up ka ng mga breakpoint upang mapasukan ang iyong code at makita na ang singleton ay gumagana bilang dapat ay. Ang aming panimulang punto ay magiging sa pangunahing.cpp ng aming proyekto at ang aming main.cpp ngayon ay mukhang imahe sa ibaba.

Binabati kita! Nakumpleto mo lang ang iyong unang pagpapatupad ng Singleton Design Pattern. Sa pattern ng disenyo na ito, maaari mo na ngayong i-streamline ang iyong code sa iba't ibang mga paraan. Halimbawa, maaari ka na ngayong gumawa ng mga system ng manager na tumatakbo sa buong oras ng pagpapatakbo ng iyong programa, na maaaring ma-access sa pamamagitan ng mga static na pag-andar kahit saan mo isinama ang klase.

Ang iyong panghuling file ng header ay dapat magmukhang larawan 7.1. Ang nauugnay na CPP file ng iyong singleton ay dapat magmukhang Larawan 6.2 na may pagdaragdag ng, sa tuktok ng file, ng code na ipinakita sa hakbang 8. Ang tagubiling ito ay nagbigay sa iyo ng isang simpleng istraktura ng Singleton Design Pattern.

Payo sa Pag-troubleshoot:

Pagkuha ng mga error na nauugnay sa memorya?

Tiyaking sumangguni ka sa hakbang 7 at hakbang 8 upang matiyak na nagtatakda ka ng ptrInstance sa nullptr.

Nangyayari ang walang katapusang loop?

Siguraduhin na para sa mga pampublikong pag-andar, sa kanilang mga kahulugan, tinawag mo ang pribadong pagpapaandar, hindi pareho ang pagpapaandar ng publiko.

Mga bagay na inilalaan sa loob ng singleton na sanhi ng paglabas ng memorya?

Siguraduhing tawagan mo ang pagwawakas ng iyong singleton kapag naaangkop sa loob ng iyong code ng programa, at sa mapanirang iyong singleton, siguraduhing inilalaan mo ang anumang mga bagay na inilalaan sa memorya sa loob ng saklaw ng singleton code.