როგორ შევზღუდოთ კლასი 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-ის გამოყენებისას. მოდიფიცირებული Singleton-ის გამოყენება შეიძლება იყოს უფრო რთული ობიექტების დესტრუქციის განხორციელებაში, განსაკუთრებით თუ მათი სიცოცხლის ციკლი არ ემთხვევა პროგრამის დასრულებას.

შერჩევა დამოკიდებულია კონკრეტულ მოთხოვნებზე და სისტემის სირთულეზე. სტატიკური გამოთვლით მეთოდი ზოგადად უფრო მარტივია გასაგებად და განხორციელებისთვის.