Ponteiro compartilhado com contagem máxima de uso predefinida

Impossível em tempo de compilação

O que você está fazendo não é possível em tempo de compilação, apenas em tempo de execução. Observe que std::shared_ptré copiável, portanto é possível que "os caminhos de cópia diverjam":

std::shared_ptr A = /* ... */;
auto B = A;
auto C = A;

Neste ponto, Bnão Csabemos nada um sobre o outro e não há como garantir que o façam através do sistema de tipos. Na melhor das hipóteses, você pode contar o comprimento do caminho da cópia até Aas Bcópias subsequentes, mas não a quantidade global de cópias.

Isso exigiria alguma forma de metaprogramação com estado e C++ não suporta isso.

Difícil em tempo de execução

Observe dois problemas:

1. std::shared_ptrtambém se espera que tenha contagem segura de threads. Isto também significa que std::shared_ptr::use_count()pode não produzir o resultado mais recente e não pode ser considerado uma métrica confiável.
2. Se você mesmo acompanhasse a contagem de uso, precisaria alocar um novo intalém do contador atômico que os ponteiros compartilhados já possuem. Isso é um pouco chato, mas factível.

Solução de thread único

Se você não considerar os problemas do multithreading, poderá apenas usar std::shared_ptr::use_count()para controlar os usos. Esta é uma métrica confiável em um programa de thread único. Você só precisa fazer um wrapper para std::shared_ptro qual será lançado sempre que o limite for excedido, o que pode acontecer no construtor de cópia e no operador de atribuição de cópia.

template <typename T, std::size_t N>
  requires (N != 0)
struct limited_shared_ptr {
    using base_type = std::shared_ptr<T, N>;
    
  private:
    base_type base;

  public:
    // OK
    limited_shared_ptr(T* ptr) : base{ptr} {}

    // The following contains an immediately invoked lambda expression in the copy
    // constructor.
    // This is clunky, but necessary so that we throw *before* we copy-construct
    limited_shared_ptr(const limited_shared_ptr& other)
      : base{[this] -> base_type& {
        if (other.use_count() >= N) {
            throw /* ... */;
        }
        return other;
    }()} {}

    limited_shared_ptr& operator=(const limited_shared_ptr& other) {
        if (this != &other &&
            base.get() != other.get() &&
            other.get() != nullptr &&
            other.use_count() >= N) {
            throw /* ... */;
        }
        base = other.base;
        return *this;
    }

    // Move assignment or destruction cannot increase the use_count(), only
    // keep it constant or decrease it, so we can keep these operations defaulted.
    limited_shared_ptr(limited_shared_ptr&& other) = default;
    limited_shared_ptr& operator=(limited_shared_ptr&&) = default;
    ~limited_shared_ptr() = default;

    // TODO: expose more of the std::shared_ptr interface
};

Solução multithread

Isso é um pouco mais complicado e fornecerei apenas o esboço geral.

Você pode criar um std::shared_ptrcom um deleter personalizado. Este eliminador personalizado pode conter um std::atomic<std::size_t>para manter um controle confiável da contagem de uso.

struct counting_deleter {
    std::atomic<std::size_t> use_count;
    void operator()(auto* ptr) const {
        delete ptr;
    }
};

Com isso, você não precisa gerenciar recursos sozinho, mas pode deixar std::shared_ptrisso e acessar o deletor a base.get_deleter<counting_deleter>()qualquer momento.

No construtor de cópia, semelhante à solução single-threaded, você verificaria:

counting_deleter* deleter = other.get_deleter<counting_deleter>();
std::size_t expected = deleter->use_count.load(std::memory_order::relaxed);
do {
    if (expected >= N) {
        // increasing the use_count would exceed the limit
        throw /* ... */;
    }
    // otherwise, attempt to increment atomically using a weak CAS
} while (!deleter->use_count.compare_exchange_weak(expected, expected + 1));
// note: the CAS can probably use std::memory_order::relaxed too

Basicamente, verificamos se é possível aumentar a contagem de uso. Caso contrário, lançamos, caso contrário, tentamos incrementar use_countwith compare_exchange_weak.

O operador de atribuição de cópia é análogo. As outras funções-membro especiais podem ser padronizadas, uma vez que mover ou destruir não pode ultrapassar o limite.

O padrão std::shared_ptr em C++ não fornece diretamente um mecanismo para definir uma contagem máxima de referência em tempo de compilação. No entanto, você pode obter um comportamento semelhante criando um ponteiro inteligente personalizado com uma contagem de referência limitada. Aqui está um exemplo básico:

#include <iostream>
#include <memory>
#include <stdexcept>

template <typename T, int MaxRefCount = 2>
class LimitedSharedPtr {
public:
    LimitedSharedPtr(T* ptr) : ptr_(ptr), refCount_(1) {
        if (refCount_ > MaxRefCount) {
            throw std::runtime_error("Exceeded maximum reference count");
        }
    }

    LimitedSharedPtr(const LimitedSharedPtr& other) : ptr_(other.ptr_), refCount_(other.refCount_) {
        if (refCount_ > MaxRefCount) {
            throw std::runtime_error("Exceeded maximum reference count");
        }
        refCount_++;
    }

    LimitedSharedPtr& operator=(const LimitedSharedPtr& other) {
        if (this != &other) {
            release();
            ptr_ = other.ptr_;
            refCount_ = other.refCount_;
            if (refCount_ > MaxRefCount) {
                throw std::runtime_error("Exceeded maximum reference count");
            }
            refCount_++;
        }
        return *this;
    }

    ~LimitedSharedPtr() {
        release();
    }

    T* get() const {
        return ptr_;
    }

private:
    void release() {
        refCount_--;
        if (refCount_ == 0) {
            delete ptr_;
        }
    }

    T* ptr_;
    int refCount_;
};

int main() {
    LimitedSharedPtr<double, 2> p(new double(2159));
    LimitedSharedPtr<double, 2> q = p; // works fine
    LimitedSharedPtr<double, 2> err1 = p; // throws runtime_error
    LimitedSharedPtr<double, 2> err2 = q; // throws runtime_error

    return 0;
}