具有预定义最大使用次数的共享指针

编译时不可能

你所做的事情在编译时是不可能的，只能在运行时进行。请注意，它std::shared_ptr是可复制的，因此“复制路径可能会出现分歧”：

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

此时，彼此之间B一无所知C，也没有办法通过类型系统确保他们做到这一点。A您最多可以计算从到以及后续副本的复制路径长度B，但不能计算全局副本数量。

这需要某种形式的有状态元编程，而 C++ 不支持这一点。

运行时困难

注意两个问题：

1. std::shared_ptr预计还具有线程安全计数。这也意味着std::shared_ptr::use_count()可能不会产生最新的结果，并且不能被视为可靠的指标。
2. 如果您自己跟踪使用计数，则int除了共享指针已有的原子计数器之外，您还需要分配一个新的计数器。这有点烦人，但可行。

单线程解决方案

如果不考虑多线程的问题，可以直接使用std::shared_ptr::use_count()来跟踪使用情况。这是单线程程序中的可靠指标。您只需要创建一个包装器，std::shared_ptr每当超出限制时就会抛出异常，这可能发生在复制构造函数和复制赋值运算符中。

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
};

多线程解决方案

这有点复杂，我只提供大概的轮廓。

您可以std::shared_ptr使用自定义删除器创建一个。该自定义删除器可以包含一个std::atomic<std::size_t>来可靠跟踪使用计数。

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

有了这个，您不需要自己管理资源，而是可以让它做并随时std::shared_ptr访问删除器。base.get_deleter<counting_deleter>()

在复制构造函数中，与单线程解决方案类似，您将检查：

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

基本上，我们检查是否可以增加使用次数。如果不是，我们抛出，否则我们尝试增加use_countwith compare_exchange_weak。

复制赋值运算符是类似的。其他特殊成员函数可以默认，因为移动或破坏不能突破限制。

C++ 中的标准 std::shared_ptr 不直接提供在编译时设置最大引用计数的机制。但是，您可以通过创建具有有限引用计数的自定义智能指针来实现类似的行为。这是一个基本示例：

#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;
}