标签：c smart-pointers
我正在编写一个智能指针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的数组,但我想不出一种方法来分配实际的对象.任何帮助表示赞赏,谢谢.
解决方法:
旧解决方案
另一个赋值运算符怎么样？
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(例如一个= new double(5))来更新所有相关的count_ptrs,把指针和计数放在一个帮助器类中,让你的指针类保存一个指向helper类的指针(你可能已经沿着这条路走下去).您可以通过两种方式填写此设计：
>使辅助类成为一个简单的结构(和一个私有内部类),并将所有逻辑放在外部类方法中
>使count_ptr成为辅助类. counting_ptr维护引用计数但不自动更新计数;它不是一个智能指针,它只响应释放和保留消息.如果您完全熟悉Objective-C,那么它基本上就是传统的内存管理(除了autoreleasing).当引用计数达到0(与Obj-C的另一个潜在差异)时,counts_ptr可能会也可能不会自行删除. counts_ptrs不应该是可复制的.意图是对于任何普通指针,最多应该有一个counts_ptr.
创建一个smart_ptr类,该类具有指向counts_ptr的指针,该指针在应该保存相同普通指针的smart_ptr实例之间共享. smart_ptr负责通过发送count_ptr版本和保留方法自动更新计数.
counting_ptr可能是也可能不是shared_ptr的私有内部类.
这是选项二的界面.因为你这是一个练习,我会让你填写方法定义.潜在的实现类似于已经发布的内容,除了你不需要copy_ptr的复制构造函数和复制赋值运算符,counts_ptr :: ~counting_ptr不会调用counting_ptr :: release(那是smart_ptr :: ~smart_ptr的工作)和counting_ptr :: release可能不会释放count_ptr :: _指针(你可以把它留给析构函数).
// 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;
};
希望上面唯一含糊不清的是有意识的.
标签：c,smart-pointers 来源： https://codeday.me/bug/20190724/1519814.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。