实现智能指针 - 使用模板进行动态分配

Question

我正在编写一个智能指针countptr,我已经达到了减速带.countsptr的基本功能是像任何其他智能指针一样工作,并且还有一个指向单个对象的指针数.到目前为止,代码是:

[解决了]

#include "std_lib_facilities.h"

template <class T>
class counted_ptr{
private:
    T* pointer;
    int* count;

public:
    counted_ptr(T* p = 0, int* c = new int(1)) : pointer(p), count(c) {}    // default constructor
    explicit counted_ptr(const counted_ptr& p) : pointer(p.pointer), count(p.count) { ++*count; } // copy constructor
    ~counted_ptr() { --*count; delete pointer; }

    counted_ptr& operator=(const counted_ptr& p)
    {
        pointer = p.pointer;
        count = p.count;
        ++*count;
        return *this;
    }
    T* operator->() const{ return pointer; }
    T& operator*() const { return *pointer; }

    int Get_count() const { return *count; }
};


int main()
{
    counted_ptr<double> one;
    counted_ptr<double>two(one);
    int a = one.Get_count();
    cout << a << endl;
}

当我尝试做类似的事情

one->pointer = new double(5);

然后我得到一个编译器错误,说"请求成员'指针'在'*(&one) - > counting_ptr :: operator->,T = double',这是非类型double".

我考虑做一个函数来做这个,虽然我可以创建一个函数来分配一个T的数组,但我想不出一种方法来分配实际的对象.任何帮助表示赞赏,谢谢.

Answer 1

旧解决方案

另一个赋值运算符怎么样？

counted_ptr& counted_ptr::operator=(T* p)
{
    if (! --*count) { delete count; }
    pointer = p;
    count = new int(1);
    return *this;
}

...

one = new double(5);

此外,您的析构函数总是删除共享指针,这可能是导致*one成为随机名词的原因.也许你想要的东西:

counted_ptr::~counted_ptr() { if (! --*count) { delete pointer; delete count; } }

新解决方案

当您想要重新计算一个counts_ptr(例如one = new double(5))来更新所有相关的counted_ptrs时,将指针和计数都放在一个帮助器类中,并让指针类保存一个指向辅助类的指针(您可能已经沿着这条路径前进).您可以通过两种方式填写此设计:

1. 使helper类成为一个简单的结构(和一个私有内部类),并将所有逻辑放在外部类方法中

2. 制作counted_ptr助手课程.counted_ptr保持引用计数但不自动更新计数; 它不是一个智能指针,它只响应release和retain消息.如果您完全熟悉Objective-C,那么这基本上就是它的传统内存管理(除了自动释放).counted_ptr当引用计数达到0(与Obj-C的另一个潜在差异)时,可能会也可能不会删除自身.counted_ptrs不应该是可复制的.意图是对于任何普通指针,最多应该有一个counted_ptr.

   创建一个smart_ptr具有指向a的指针的类,该指针counted_ptr在smart_ptr应该保存相同普通指针的实例之间共享.smart_ptr负责通过发送其counted_ptr发布和保留方法自动更新计数.

   counted_ptr可能是也可能不是私人的内部阶级shared_ptr.

这是选项二的界面.因为你这是一个练习,我会让你填写方法定义.潜在的实现类似于已发布的内容,除了您不需要复制构造函数和复制赋值运算符counted_ptr,counted_ptr::~counted_ptr不调用counted_ptr::release(这smart_ptr::~smart_ptr是工作)并且counted_ptr::release可能不会释放counted_ptr::_pointer(您可能将其留给析构函数) .

// counted_ptr owns its pointer an will free it when appropriate.
template <typename T>
class counted_ptr {
private:
    T *_pointer;
    size_t _count;

    // Make copying illegal
    explicit counted_ptr(const counted_ptr&);
    counted_ptr& operator=(const counted_ptr<T>& p);

public:
    counted_ptr(T* p=0, size_t c=1);
    ~counted_ptr();

    void retain();        // increase reference count.
    bool release();       // decrease reference count. Return true iff count is 0
    void reassign(T *p);  // point to something else.
    size_t count() const;

    counted_ptr& operator=(T* p);

    T& operator*() const;
    T* operator->() const;
};

template <typename T>
class smart_ptr {
private:
    counted_ptr<T> *_shared;
    void release();  // release the shared pointer
    void retain();   // retain the shared pointer

public:
    smart_ptr(T* p=0, int c=1);   // make a smart_ptr that points to p
    explicit smart_ptr(counted_ptr<T>& p); // make a smart_ptr that shares p
    explicit smart_ptr(smart_ptr& p); // copy constructor
    ~smart_ptr();

    // note: a smart_ptr's brethren are the smart_ptrs that share a counted_ptr.
    smart_ptr& operator=(smart_ptr& p); /* Join p's brethren. Doesn't alter pre-call
        * brethren. p is non-const because this->_shared can't be const. */
    smart_ptr& operator=(counted_ptr<T>& p);  /* Share p. Doesn't alter brethren. 
        * p is non-const because *this isn't const. */
    smart_ptr& operator=(T* p); // repoint this pointer. Alters brethren

    size_t count() const; // reference count

    T& operator*() const;  // delegate these to _shared
    T* operator->() const;

};

希望上面唯一含糊不清的是有意识的.