Hogyan korlátozhatjuk egy osztály példányainak számát…

Különböző módszerek léteznek, a főbbek a következők:

Statikus int változó használata számlálóként:

Hozzon létre egy statikus int változót az példányok számának nyomon követésére.
Növelje a számlálót a konstruktorban.
Csökkentse a számlálót a destruktorban.
A konstruktorban ellenőrizze a számláló értékét, és ha az meghaladja a limitet, dobjon kivételt vagy tegyen más lépéseket.
Tegye a konstruktor priváttá vagy védetté, és példányt a statikus gyárfüggvényen keresztül hozzon létre, amely elvégzi az ellenőrzést.
Tiltson meg másolást és mozgatást.

#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("Elérte a maximális példányszámot.");
        }
        instance_count++;
        std::cout << "Példány létrehozva. Összesen: " << instance_count << std::endl;
    }

    // Másolás és mozgatás tiltása
    LimitedInstances(const LimitedInstances&) = delete;
    LimitedInstances& operator=(const LimitedInstances&) = delete;
    LimitedInstances(LimitedInstances&&) = delete;
    LimitedInstances& operator=(LimitedInstances&&) = delete;

public:
    ~LimitedInstances() {
        instance_count--;
        std::cout << "Példány megsemmisítve. Összesen: " << instance_count << std::endl;
    }

    static LimitedInstances* create_instance() {
        return new LimitedInstances();
    }
};

int LimitedInstances::instance_count = 0;

Singleton mintázat módosítással:

Általában a Singleton garantálja az egy példányt. Az példányszám korlátozásához módosíthatja, az elérését statikus függvényen keresztül kezelve, és nyomon követve a létrehozott objektumokat egy privát statikus konténerben (pl. std::vector vagy 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 létrehozva." << std::endl;
    }

    // Másolás és mozgatás tiltása
    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("Elérte a maximális NLimitedInstances számot.");
        }
        NLimitedInstances* new_instance = new NLimitedInstances();
        instances.push_back(new_instance);
        return new_instance;
    }

    static void destroy_instance(NLimitedInstances* instance) {
        // Keresés és példány törlése a vektorban
        for (auto it = instances.begin(); it != instances.end(); ++it) {
            if (*it == instance) {
                delete *it;
                instances.erase(it);
                std::cout << "NLimitedInstances megsemmisítve." << std::endl;
                return;
            }
        }
    }

    ~NLimitedInstances() = default; // vagy hozzáadni a takarítási logikát
};

std::vector<NLimitedInstances*> NLimitedInstances::instances;

Mindkét megközelítés gondos erőforrás-kezelést igényel, különösen a new használata esetén. A Singleton módosított mintázata bonyolultabb lehet az objektumok destrukciójának megvalósításában, különösen, ha életciklusuk nem egyezik a program végével.

A módszer kiválasztása a konkrét követelményektől és a rendszer összetettségétől függ. A statikus számlálóval való megközelítés általában egyszerűbb a megértés és a kivitelezés szempontjából.

Hogyan korlátozhatjuk egy osztály példányainak számát C++-ban?