Kā ierobežot klases instanču skaitu C++?

Ir vairākas metodes, galvenās:

1. Statiskā skaitītāja izmantošana:

   • Izveidot int tipa statisku mainīgo, kas uzraudzīs izveidoto eksemplāru skaitu:
   • Skaitītāja palielināšana konstruktorā:
   • Skaitītāja samazināšana destruktorā:
   • Konstruktorā pārbaudīt skaitītāja vērtību un, ja pārsniegts limits, mest izņēmumu vai veikt citas darbības:
   • Padarīt konstruktoru privātu vai aizsargātu un izveidot eksemplārus caur statisku fabrika funkciju, kas veic pārbaudi:
   • Aizliegt kopēšanu un pārvietošanu:

   #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;
       }
   
       // Aizliegt kopēšanu un pārvietošanu
       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 šablona ar modifikāciju:

   • Parasti Singleton garantē vienu eksemplāru. Lai ierobežotu skaitu, to var modificēt, pārvaldot piekļuvi izveidei caur statisku funkciju un uzraugot izveidotos objektus privātā statiskā konteinerā (piemēram, std::vector vai 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;
       }
   
       // Aizliegt kopēšanu un pārvietošanu
       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) {
           // Meklē un iznīcina eksemplāru no vektora
           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; // vai pievienot tīrīšanas loģiku
   };
   
   std::vector<NLimitedInstances*> NLimitedInstances::instances;
   

Abi pieejas prasa rūpīgu resursu pārvaldību, īpaši, izmantojot new. Modificētā Singleton versija var būt sarežģītāka objektu destrukcijā, īpaši, ja to dzīves cikls nesakrīt ar programmas beigām.

Izvēle ir atkarīga no konkrētajām prasībām un sistēmas sarežģītības. Statiskā skaitītāja pieeja kopumā ir vienkāršāka sapratnei un īstenošanai.