Существует несколько способов, основные:

Использование статической переменной-счетчика:

Завести статическую переменную типа 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;

Использование паттерна 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;

Оба подхода требуют careful resource management, особенно при использовании new. Паттерн Singleton с модификацией может быть более сложным в реализации деструкции объектов, особенно если их жизненный цикл не совпадает с завершением программы.

Выбор метода зависит от конкретных требований и сложности системы. Подход с статическим счетчиком в целом проще для понимания и реализации.

Как ограничить количество экземпляров класса в C++?