Ինչպես սահմանափակել C++-ում դասի օրինակների քանակը?

Կան մի քանի մեթոդներ, հիմնականները՝

1. Ստատիկ փոփոխականի հաշվիչի օգտագործում:

   • Ստեղծել int տիպի ստատիկ փոփոխական՝ ստեղծված օրինակների քանակը հետևելու համար:
   • Հաշվիչը ավելացնել կոնստրուկտորում:
   • Հաշվիչը նվազեցնել դեստրուկտորում:
   • Կոնստրուկտորում ստուգել հաշվիչի արժեքը և, եթե սահմանաչափը գերազանցված է, նետել բացառություն կամ ձեռնարկել այլ գործողություններ:
   • Գործարկել կոնստրուկտորը որպես մասնավոր կամ պաշտպանված և ստեղծել օրինակները ստատիկ ֆաբրիկային ֆունկցիայի միջոցով, որը կատարում է ստուգում:
   • արգելել պատճենահանումը և տեղափոխումը:

   #include <iostream>
   #include <stdexcept>
   
   class LimitedInstances {
   private:
       static int instance_count;
       static const int max_instances = 3;
   
       LimitedInstances() {
           if (instance_count >= max_instances) {
               throw std::runtime_error("Maximum number of instances reached.");
           }
           instance_count++;
           std::cout << "Instance created. Total: " << instance_count << std::endl;
       }
   
       // արգելել պատճենահանումը և տեղափոխումը
       LimitedInstances(const LimitedInstances&) = delete;
       LimitedInstances& operator=(const LimitedInstances&) = delete;
       LimitedInstances(LimitedInstances&&) = delete;
       LimitedInstances& operator=(LimitedInstances&&) = delete;
   
   public:
       ~LimitedInstances() {
           instance_count--;
           std::cout << "Instance destroyed. Total: " << instance_count << std::endl;
       }
   
       static LimitedInstances* create_instance() {
           return new LimitedInstances();
       }
   };
   
   int LimitedInstances::instance_count = 0;
   

2. Singleton պատկերակրի օգտագործում՝ փոփոխությամբ:

   • սովորաբար Singleton-ը երաշխավորում է մեկ օրինակ։ Օրվա սահմանափակման համար, կարելի է փոփոխել այն՝ կառավարելով ստեղծման հասանելիությունը ստատիկ ֆունկցիայի միջոցով և հետևելով ստեղծված օբյեկտներին մասնավոր ստատիկ կոնտեյներով (օր., std::vector կամ std::list):

   #include <iostream>
   #include <vector>
   #include <stdexcept>
   
   class NLimitedInstances {
   private:
       static std::vector<NLimitedInstances*> instances;
       static const int max_instances = 2;
   
       NLimitedInstances() {
           std::cout << "NLimitedInstances created." << std::endl;
       }
   
       // արգելել պատճենահանումը և տեղափոխումը
       NLimitedInstances(const NLimitedInstances&) = delete;
       NLimitedInstances& operator=(const NLimitedInstances&) = delete;
       NLimitedInstances(NLimitedInstances&&) = delete;
       NLimitedInstances& operator=(NLimitedInstances&&) = delete;
   
   public:
       static NLimitedInstances* get_instance() {
           if (instances.size() >= max_instances) {
                throw std::runtime_error("Maximum number of NLimitedInstances reached.");
           }
           NLimitedInstances* new_instance = new NLimitedInstances();
           instances.push_back(new_instance);
           return new_instance;
       }
   
       static void destroy_instance(NLimitedInstances* instance) {
           // որոնել և հեռացնել օրինակն վեկտորից
           for (auto it = instances.begin(); it != instances.end(); ++it) {
               if (*it == instance) {
                   delete *it;
                   instances.erase(it);
                   std::cout << "NLimitedInstances destroyed." << std::endl;
                   return;
               }
           }
       }
   
       ~NLimitedInstances() = default; // կամ ավելացնել մաքրման լոգիկա
   };
   
   std::vector<NLimitedInstances*> NLimitedInstances::instances;
   

Երկու մոտեցումները պահանջում են ուշադիր ռեսուրսների կառավարում, հատկապես new օգտագործելիս։ Սինգլետոն պատկերակրի փոփոխությունը կարող է ավելի բարդ լինել օբյեկտների դեստրուկցիայի իրականացման մեջ, հատկապես եթե նրանց կյանքի ցիկլը չի համընկնում ծրագրի ավարտին։

Ընտրությունը կախված է կոնկրետ պահանջներից և համակարգի բարդությունից։ Ստատիկ հաշվիչով մոտեցումը ընդհանուր առմամբ պարզ է հասկանալու և իրականացնելուն։