C++ 自定义智能指针

Question

最近我尝试实现我自己的智能指针版本。实现看起来有点像下面：

class Var {
private:
    void* value;
    unsigned short* uses;
public:
    Var() : value(nullptr), uses(new unsigned short(1)) { }
    template<typename K>
    Var(K value) : value((void*)new K(value)), uses(new unsigned short(1)) { }
    Var(const Var &obj) {
        value = obj.value;
        (*(uses = obj.uses))++;
    }
    ~Var() {
        if (value == nullptr && uses == nullptr) return;
        if (((*uses) -= 1) <= 0) {
            delete value;
            delete uses;
            value = uses = nullptr;
        }
    }
    Var& operator=(const Var& obj) {
        if (this != &obj) {
            this->~Var();
            value = obj.value;
            (*(uses = obj.uses))++;
        }
        return *this;
    }
};

实现应该是直截了当的，因为value 持有指针，uses 计算引用。
请注意，指针存储为void*，并且指针类未固定为某些（通用）类型。

问题

智能指针在大多数情况下都在发挥作用……但以下情况除外：

class C {
public:
    Var var;
    C(Var var) : var(var) {}
};
void test() {
    std::string string = std::string("Heyo");
    Var var1 = Var(string);
    C c = C(var1);
    Var var2 = Var(c);
}
void main() {
    test();
}

运行该代码时，第一个实例var1 在test 运行后不会被删除。
是的，使用void* 并不是最好的方法。然而，让我们不要离开话题。代码编译得非常好（如果有人可能会质疑我对子分配运算符的使用）。如果错误出现在删除 void* 中，则引用计数器 uses 将被删除，但事实并非如此。
我之前已经检查过析构函数，它们都被调用了。
还要注意程序运行时没有错误。

提前谢谢大家，
谢尔顿

Answer 1

我看到您的代码存在三个大问题：

1. 您将分配的对象指针存储为void*，然后按原样调用delete。这不会调用对象的析构函数。在调用delete 之前，您必须将void* 类型转换回原始类型，但您不能这样做，因为在Var 构造函数退出后您已经丢失了类型信息。

2. 您已将对象指针和引用计数器彼此分开。它们应始终保持在一起。最好的方法是将它们存储在 struct 中，然后根据需要进行分配和传递。

3. 您的operator= 正在调用this->~Var()，这是完全错误的。一旦你这样做了，this 指向的对象就不再有效！您需要保持实例处于活动状态，因此只需减少其当前引用计数器，如果需要释放其存储的对象，然后从源 Var 复制指针并增加该引用计数器。

试试这个替代实现 (Live Demo)：

class Var
{
private:
    struct controlBlockBase
    {
        unsigned short uses;    

        controlBlockBase() : uses(1) { }
        virtual ~controlBlockBase() { }
    };

    template <class K>
    struct controlBlockImpl : controlBlockBase
    {
        K value;
        controlBlockImpl(const K &val) : controlBlockBase(), value(val) {}
    };

    controlBlockBase *cb;

public:
    Var() : cb(nullptr) { }

    template<typename K>
    Var(const K &value) : cb(new controlBlockImpl<K>(value)) { }

    Var(const Var &obj) : cb(obj.cb) {
        if (cb) {
            ++(cb->uses);
        }
    }

    Var(Var &&obj) : cb(nullptr) {
        obj.swap(*this);
    }

    ~Var() {
        if ((cb) && ((cb->uses -= 1) <= 0)) {
            delete cb;
            cb = nullptr;
        }
    }

    Var& operator=(const Var& obj) {
        if (this != &obj) {
            Var(obj).swap(*this);
        }
        return *this;
    }

    Var& operator=(Var &&obj) {
        obj.swap(*this);
        return *this;
    }

    /* or, the two above operator= codes can be
    merged into a single implementation, where
    the input parameter is passed by non-const
    value and the compiler decides whether to use
    copy or move semantics as needed:

    Var& operator=(Var obj) {
        obj.swap(*this);
        return *this;
    }    
    */

    void swap(Var &other)
    {
        std::swap(cb, other.cb);
    }

    unsigned short getUses() const {
        return (cb) ? cb->uses : 0;
    }

    template<class K>
    K* getAs() {
        if (!cb) return nullptr;
        return &(dynamic_cast<controlBlockImpl<K>&>(*cb).value);
    }
};

void swap(Var &v1, Var v2) {
    v1.swap(v2);
}

---

更新：话虽这么说，Var 所做的基本上与使用 std::any 包裹在 std::shared_ptr 中的效果相同，所以您不妨直接使用它们（ std::any 仅适用于 C++17 及更高版本，早期版本使用 boost::any）：

class Var
{
private:
    std::shared_ptr<std::any> ptr;

public:
    template<typename K>
    Var(const K &value) : ptr(std::make_shared<std::any>(value)) { }

    void swap(Var &other) {
        std::swap(ptr, other.ptr);
    }

    long getUses() const {
        return ptr.use_count();
    }

    template<class K>
    K* getAs() {
        return any_cast<K>(ptr.get());
    }
};

void swap(Var &v1, Var &v2) {
    v1.swap(v2);
}