Re: Reference Counting
Protoman wrote:
OK, this code compiles, links, and executes, but, how do I setup, like,
a spinlock to query the DataBase object's status to let the SmrtPtr
know that the object's been deleted?:
#pragma once
class SmrtPtrDB
{
public:
SmrtPtrDB():num(0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--;}
int status(){return num;}
private:
int num;
};
#pragma once
#include "SmrtPtrDB.hpp"
template<class T>
class SmrtPtr
{
public:
SmrtPtr<T>(T* obj=0):ptr(obj){DataBase.add();)
SmrtPtr<T>(const SmrtPtr<T>& rhs):ptr(new
T(*(rhs.ptr))){DataBase.add();}
~SmrtPtr<T>(){delete ptr; ptr=0; DataBase.sub();}
void operator=(T val){*ptr=val;}
SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
delete ptr;
ptr(rhs.ptr);
}
else return this;
}
int status(){DataBase.status();}
T& operator*()const{return *ptr;}
T* operator->()const{return ptr;}
private:
SmrtPtrDB DataBase;
T* ptr;
};
I'm very confused. Am I implementing this right? Thanks!!!!
This is our current counted pointer code:
//
//counted_ptr - simple reference counted pointer.
//
//The is a non-intrusive implementation that allocates an additional
//int and pointer for every counted object.
#ifndef __COUNTED_PTR_H
#define __COUNTED_PTR_H
template <class X> class counted_ptr
{
public:
typedef X element_type;
explicit counted_ptr(X* p = 0) // allocate a new counter
: itsCounter(0) {if (p) itsCounter = new counter(p);}
~counted_ptr()
{release();}
counted_ptr(const counted_ptr& r) throw()
{acquire(r.itsCounter);}
counted_ptr& operator=(const counted_ptr& r)
{
if (this != &r) {
release();
acquire(r.itsCounter);
}
return *this;
}
template <class Y>
counted_ptr(const counted_ptr<Y>& r) throw()
{acquire(r.itsCounter);}
template <class Y>
counted_ptr& operator=(const counted_ptr<Y>& r)
{
if (this != &r) {
release();
acquire(r.itsCounter);
}
return *this;
}
X& operator*() const throw() {return *itsCounter->ptr;}
X* operator->() const throw() {return itsCounter->ptr;}
X* get() const throw() {return itsCounter ?
itsCounter->ptr : 0;}
bool unique() const throw()
{return (itsCounter ? itsCounter->count == 1 : true);}
private:
struct counter {
counter(X* p = 0, unsigned c = 1) : ptr(p), count(c) {}
X* ptr;
unsigned count;
}* itsCounter;
void acquire(counter* c) throw()
{ // increment the count
itsCounter = c;
if (c) ++c->count;
}
void release()
{ // decrement the count, delete if it is 0
if (itsCounter) {
if (--itsCounter->count == 0) {
delete itsCounter->ptr;
delete itsCounter;
}
itsCounter = 0;
}
}
};
#endif