Reference Counting

P

Protoman

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!!!!
 
J

Jon Rea

Protoman said:
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!!!!
Click to expand...

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
 
G

Gianni Mariani

It's very hard to understand what it is you're trying to do.

Could you write a snippet of code that describes more about what you're
trying to achieve ? More like a test case for your smart pointer ...
 
P

Protoman

Gianni said:
It's very hard to understand what it is you're trying to do.

Could you write a snippet of code that describes more about what you're
trying to achieve ? More like a test case for your smart pointer ...
Click to expand...

Actually here's the code; it achieves reference counting (I hope!!!)

SmrtPtrDB.hpp

#pragma once

class SmrtPtrDB
{
public:
SmrtPtrDB():num(1){}
SmrtPtrDB(const SmrtPtrDB& rhs):num(rhs.num){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--;}
int status(){return num;}
private:
int num;
};

SmrtPtr.hpp

template<class T>
class SmrtPtr
{
public:
SmrtPtr<T>(T* obj=0):ptr(obj){}
SmrtPtr<T>(const SmrtPtr<T>& rhs):ptr(rhs.ptr){DataBase.add();}
~SmrtPtr<T>()
{
DataBase.sub();
if(DataBase.status()==0)
{delete ptr;cout << "Deleted.";}
else cout << "Out of scope. " << endl;
}
void operator=(T val){*ptr=val;}
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(){return DataBase.status();}
T& operator*()const{return *ptr;}
T* operator->()const{return ptr;}
operator T*()const{return ptr;}
private:
SmrtPtrDB DataBase;
T* ptr;
};

main.cpp

#include <iostream>
#include <cstdlib>
#include "SmrtPtr.hpp"
using namespace std;

int main()
{
{
SmrtPtr<int> ptr(new int);
ptr=5;
cout << *ptr << endl;
{
SmrtPtr<int> ptr2(ptr);
ptr2=6;
cout << *ptr << endl;
cout << *ptr2 << endl;
}
cout << *ptr << endl;
}
system("PAUSE");
return EXIT_SUCCESS;
}


It works apparently. Could you help me improve? Thanks!!!!
 
T

Thomas J. Gritzan

Protoman said:
Gianni said:
It's very hard to understand what it is you're trying to do.

Could you write a snippet of code that describes more about what you're
trying to achieve ? More like a test case for your smart pointer ...
Click to expand...

Actually here's the code; it achieves reference counting (I hope!!!)
[...]
system("PAUSE");
return EXIT_SUCCESS;
}


It works apparently. Could you help me improve? Thanks!!!!
Click to expand...

You could start by
1) not using platform dependent things like system("PAUSE");
2) using whitespace (indentation),
3) describing, what you want to improve.

Well, I don't think that it works, because your SmrtPtr<> class holds a
SmrtPtrDB class (the ref counter) by value, while there should be only
one counter per object, shared by the smart pointers. Also, you should
handle operator=() by decrementing the count of the old object and
incrementing the new one.
 
P

Protoman

Thomas said:
Protoman said:
Gianni said:
Jon Rea wrote:
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?:
It's very hard to understand what it is you're trying to do.

Could you write a snippet of code that describes more about what you're
trying to achieve ? More like a test case for your smart pointer ...
Click to expand...

Actually here's the code; it achieves reference counting (I hope!!!)
[...]
system("PAUSE");
return EXIT_SUCCESS;
}


It works apparently. Could you help me improve? Thanks!!!!
Click to expand...

You could start by
1) not using platform dependent things like system("PAUSE");
2) using whitespace (indentation),
3) describing, what you want to improve.

Well, I don't think that it works, because your SmrtPtr<> class holds a
SmrtPtrDB class (the ref counter) by value, while there should be only
one counter per object, shared by the smart pointers. Also, you should
handle operator=() by decrementing the count of the old object and
incrementing the new one.
Click to expand...

Which one's the "old object", the one of the right side of operator=,
or the left side? And do you mean this:

SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
this->DataBase.sub();
delete ptr;
ptr(rhs.ptr);
rhs->DataBase.add();
}
else return this;
}

So, should DataBase be held by reference? And, system("PAUSE") is the
only way I can see my output, otherwise, the console opens and closes
before I get a chance to review. And I want to improve the handling of
the reference count; I don't think my impl is very effecient or
effective. And speed. And the handling of a null pointer, like if
someone writes:

SmrtPtr<int> ptr;

ptr will be initialized to null with my ctor, so deferencing it will be
illegal. I think it should throw an exception.
 
M

Marcus Kwok

Protoman said:
And, system("PAUSE") is the
only way I can see my output, otherwise, the console opens and closes
before I get a chance to review.
Click to expand...

A standards-compliant way to achieve a similar effect is:

std::cout << "\nPress <Enter> to continue...\n";
std::string trash;
std::getline(std::cin, trash);
 
T

Thomas J. Gritzan

Protoman said:
Which one's the "old object", the one of the right side of operator=,
or the left side?
Click to expand...

By assigning one smart pointer to another, you release the pointer on
the left hand side and copy the pointer from the right hand side to the
other.
So you have to decrement the lhs counter and increment the rhs counter.
But you must not delete the lhs pointer when the counter is not zero.
SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
this->DataBase.sub();
delete ptr;
Click to expand...

Here you delete ptr. Don't do it when the counter is not zero.
ptr(rhs.ptr);
rhs->DataBase.add();
Click to expand...

rhs is const and DataBase is private. This line should not work.
}
else return this;
}

So, should DataBase be held by reference?
Click to expand...

By pointer. Look at the implementation of other smart pointers, like
shared_ptr from boost.

Buy a good C++ book and read it.
And, system("PAUSE") is the
only way I can see my output, otherwise, the console opens and closes
before I get a chance to review.
Click to expand...

My IDE (Visual Studio) does this for me.
 
J

Joe Seigh

Thomas said:
By assigning one smart pointer to another, you release the pointer on
the left hand side and copy the pointer from the right hand side to the
other.
So you have to decrement the lhs counter and increment the rhs counter.
But you must not delete the lhs pointer when the counter is not zero.
Click to expand...

The standard way of doing this is to do a copy ctor on the source,
swap with the destination, and let the dtor for the local copy,
which is now the destination, run when it goes out of scope

SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs) {
SmrtPtr<T> temp(rhs);
swap(temp);
return *this;
}

You're safe in the case of source and destination being the same
since the refcount will be incremented before it gets decremented.
 
P

Protoman

Joe said:
The standard way of doing this is to do a copy ctor on the source,
swap with the destination, and let the dtor for the local copy,
which is now the destination, run when it goes out of scope

SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs) {
SmrtPtr<T> temp(rhs);
swap(temp);
return *this;
}

You're safe in the case of source and destination being the same
since the refcount will be incremented before it gets decremented.


--
Joe Seigh

When you get lemons, you make lemonade.
When you get hardware, you make software.
Click to expand...

OK, here's the new SmrtPtr class:

// COPYRIGHT CMDR DOUGLAS I. PEREIRA 07/10/06
// ALL UNAUTHORIZED THIRD PARTY USE IS PROHIBITED
// I HAVE WORKED VERY HARD AND HAVE SPENT HOURS OF
// TIME DEVELOPING THIS. DO NOT COPY IT OR I WILL SUE YOU
// ************************************************************
#pragma once
#include <iostream>
#include "SmrtPtrDB.hpp"
using namespace std;
class NullPtr{};
template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr<T>(T* obj=0):ptr(obj), DataBase(new SmrtPtrDB){}
SmrtPtr<T>(const SmrtPtr<T>& rhs):ptr(rhs.ptr), DataBase(new
SmrtPtrDB(rhs.DataBase->status())){DataBase->add();}
~SmrtPtr<T>()
{
DataBase->sub();
if(DataBase->status()==0)
{delete ptr;cout << "Deleted." << endl;}
else cout << "Out of scope. " << endl;
}
void operator=(T val){if(ptr==0)throw NullPtr();else *ptr=val;}
void operator=(T* val){ptr=val;}
SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
SmrtPtr<T> temp(rhs);
swap(temp);
}
else return *this;
}
bool operator==(const SmrtPtr<T>& rhs)const{if(ptr==rhs.ptr)return
true;else return false;}
bool operator!=(const SmrtPtr<T>& rhs)const{if(ptr!=rhs.ptr)return
true;else return false;}
bool operator<=(const SmrtPtr<T>& rhs)const{if(ptr<=rhs.ptr)return
true;else return false;}
bool operator>=(const SmrtPtr<T>& rhs)const{if(ptr>=rhs.ptr)return
true;else return false;}
int status(){return DataBase->status();}
T& operator*()const{if(ptr==0)throw NullPtr();else return *ptr;}
T* operator->()const{if(ptr==0)throw NullPtr();else return ptr;}
operator T*()const{if(ptr==0)throw NullPtr();else return ptr;}
private:
void swap(SmrtPtr<T>& rhs){this=&rhs;}
mutable SmrtPtrDB* DataBase;
T* ptr;
};

Did I impl swap() correctly? Should DataBase be mutable?
 
J

Joe Seigh

Protoman said:
SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
SmrtPtr<T> temp(rhs);
swap(temp);
}
else return *this;
}
Click to expand...

Ah, I was going to mention not testing if the target
and source were the same. One, it doesn't hurt anything
if you don't test for it. Two, you increased your mainline
path for something that occurs very rarely. When was the
last time you saw a program assign a variable to itself?

....
private:
void swap(SmrtPtr<T>& rhs){this=&rhs;}
mutable SmrtPtrDB* DataBase;
T* ptr;
};

Did I impl swap() correctly? Should DataBase be mutable?
Click to expand...

swap should swap the contents of *this and rhs. Your
basically faking things out so the destructor runs on
the old target ptr.

void swap(SmrtPtr<T>& rhs) {
SmrtPtrDB* dbTemp = rhs.Database;
T* ptrTemp = rhs.ptr;
rhs.Database = Database;
rhs.ptr = ptr;
Database = dbTemp;
ptr = ptrTemp;
}

Something like that.
 
P

Protoman

Joe said:
Ah, I was going to mention not testing if the target
and source were the same. One, it doesn't hurt anything
if you don't test for it. Two, you increased your mainline
path for something that occurs very rarely. When was the
last time you saw a program assign a variable to itself?

...


swap should swap the contents of *this and rhs. Your
basically faking things out so the destructor runs on
the old target ptr.

void swap(SmrtPtr<T>& rhs) {
SmrtPtrDB* dbTemp = rhs.Database;
T* ptrTemp = rhs.ptr;
rhs.Database = Database;
rhs.ptr = ptr;
Database = dbTemp;
ptr = ptrTemp;
}

Something like that.


--
Joe Seigh

When you get lemons, you make lemonade.
When you get hardware, you make software.
Click to expand...

OK, what if I wrote:

void swap(SmrtPtr<T>& rhs)
{
*this=rhs;
}

No, wait...

OK what about:

void swap(SmrtPtr<T>& rhs)
{
std::swap(ptr,rhs.ptr);
std::swap(DataBase,rhs.DataBase);
}

which is what I'm currently doing. And, self-assignment can happen in a
very large program, where you have multiple references to the same
thing, and the like. It's always good to test for it. And when I write
this, the console opens and shuts:

SmrtPtr<T> temp(ptr);
ptr=ptr2;
ptr2=temp;

Why is that?
 
T

Thomas J. Gritzan

Protoman said:
OK, here's the new SmrtPtr class:

// COPYRIGHT CMDR DOUGLAS I. PEREIRA 07/10/06
// ALL UNAUTHORIZED THIRD PARTY USE IS PROHIBITED
// I HAVE WORKED VERY HARD AND HAVE SPENT HOURS OF
// TIME DEVELOPING THIS. DO NOT COPY IT OR I WILL SUE YOU
// ************************************************************
#pragma once
#include <iostream>
#include "SmrtPtrDB.hpp"
using namespace std;
class NullPtr{};
template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr<T>(T* obj=0):ptr(obj), DataBase(new SmrtPtrDB){}
SmrtPtr<T>(const SmrtPtr<T>& rhs):ptr(rhs.ptr), DataBase(new
SmrtPtrDB(rhs.DataBase->status())){DataBase->add();}
Click to expand...

The smartpointers should _share_ a common SmrtPtrDB, if they share a
common object pointer. Here you create another copy of SmrtPtrDB in the
copy constructor.
~SmrtPtr<T>()
{
DataBase->sub();
if(DataBase->status()==0)
{delete ptr;cout << "Deleted." << endl;}
else cout << "Out of scope. " << endl;
}
Click to expand...

You don't delete the SmrtPtrDB.
void operator=(T val){if(ptr==0)throw NullPtr();else *ptr=val;}
Click to expand...

Remove this. The user should dereference the smart pointer to access its
value.
void operator=(T* val){ptr=val;}
Click to expand...

Here you should release the old ptr/SmrtPtrDB and create a new pair.
Something like this:

void operator=(T* val)
{
SmrtPtr<T> temp(val);
swap(temp);
}
SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
if(this!=&rhs)
{
SmrtPtr<T> temp(rhs);
swap(temp);
}
else return *this;
}
Click to expand...

You return *this in the "else" but not in the "if". Why?
bool operator==(const SmrtPtr<T>& rhs)const{if(ptr==rhs.ptr)return
true;else return false;}
bool operator!=(const SmrtPtr<T>& rhs)const{if(ptr!=rhs.ptr)return
true;else return false;}
bool operator<=(const SmrtPtr<T>& rhs)const{if(ptr<=rhs.ptr)return
true;else return false;}
bool operator>=(const SmrtPtr<T>& rhs)const{if(ptr>=rhs.ptr)return
true;else return false;}
int status(){return DataBase->status();}
T& operator*()const{if(ptr==0)throw NullPtr();else return *ptr;}
T* operator->()const{if(ptr==0)throw NullPtr();else return ptr;}
operator T*()const{if(ptr==0)throw NullPtr();else return ptr;}
private:
void swap(SmrtPtr<T>& rhs){this=&rhs;}
Click to expand...

Better this way:
void swap(SmrtPtr<T>& rhs)
{
std::swap(ptr,rhs.ptr);
std::swap(DataBase,rhs.DataBase);
}
Click to expand...
mutable SmrtPtrDB* DataBase;
T* ptr;
};
Click to expand...

Well, your operator= should return *this by reference, as every
operator= does.

Anyway, if you won't get your indentation right, I won't read your code
anymore. It is horrible...
 
P

Protoman

Thomas said:
The smartpointers should _share_ a common SmrtPtrDB, if they share a
common object pointer. Here you create another copy of SmrtPtrDB in the
copy constructor.


You don't delete the SmrtPtrDB.


Remove this. The user should dereference the smart pointer to access its
value.


Here you should release the old ptr/SmrtPtrDB and create a new pair.
Something like this:

void operator=(T* val)
{
SmrtPtr<T> temp(val);
swap(temp);
}


You return *this in the "else" but not in the "if". Why?


Better this way:


Well, your operator= should return *this by reference, as every
operator= does.

Anyway, if you won't get your indentation right, I won't read your code
anymore. It is horrible...
Click to expand...

For swap(), how about *this=rhs? Will that work?

Here's the stuff I fixed:

~SmrtPtr<T>()
{
DataBase->sub();
if(DataBase->status()==0)
{
delete ptr;
delete DataBase;
cout << "Deleted." << endl;
}
else
{
delete DataBase;
cout << "Out of scope. " << endl;
}
}

void operator=(T* val)
{
SmrtPtr<T> temp(val);
swap(temp);
}

SmrtPtr<T>& operator=(const SmrtPtr<T>& rhs)
{
SmrtPtr<T> temp(rhs);
swap(temp);
return *this;
}

void swap(const SmrtPtr<T>& rhs){*this=rhs;}


Sorry about my indenting, it looks normal on my screen.
 
T

Thomas J. Gritzan

Protoman said:
For swap(), how about *this=rhs? Will that work?
Click to expand...

No, swap() _swaps_ the contents, *this=rhs assigns the rhs to the lhs
(lhs gets overridden).
Here's the stuff I fixed:

~SmrtPtr<T>()
{
DataBase->sub();
if(DataBase->status()==0)
{
delete ptr;
delete DataBase;
cout << "Deleted." << endl;
}
else
{
delete DataBase;
Click to expand...

Really, think about what you are doing here. Ask yourself this questions:

- Who is the owner of the object pointed to by ptr? Who may delete it
and when?
- Who owns DataBase, who deletes it?
Sorry about my indenting, it looks normal on my screen.
Click to expand...

Try another newsreader, or try spaces instead of tabs.
 
P

Protoman

Thomas said:
No, swap() _swaps_ the contents, *this=rhs assigns the rhs to the lhs
(lhs gets overridden).


Really, think about what you are doing here. Ask yourself this questions:

- Who is the owner of the object pointed to by ptr? Who may delete it
and when?
- Who owns DataBase, who deletes it?


Try another newsreader, or try spaces instead of tabs.
Click to expand...

So, how do I fix it?
 
P

Protoman

Protoman said:
So, how do I fix it?
Click to expand...

OK, I fixed the above, but, now I'm wondering: is SmrtPtr<T> safe to
use in a container, such as a linked list? Is it thread safe?
 
T

Thomas J. Gritzan

Protoman schrieb:
[ SmrtPtr said:
OK, I fixed the above, but, now I'm wondering: is SmrtPtr<T> safe to
use in a container, such as a linked list? Is it thread safe?
Click to expand...

Depends on the container, if it can be used with it.

For the standard container classes, the values have to have
value-semantics. If your smart pointer works as it should, then its safe
to use in on of them.

For thread safety: Don't ask here, since C++ doesn't know about threads
(you should know this already)
 
P

Protoman

Thomas said:
Protoman schrieb:
[ SmrtPtr said:
OK, I fixed the above, but, now I'm wondering: is SmrtPtr<T> safe to
use in a container, such as a linked list? Is it thread safe?
Click to expand...

Depends on the container, if it can be used with it.

For the standard container classes, the values have to have
value-semantics. If your smart pointer works as it should, then its safe
to use in on of them.

For thread safety: Don't ask here, since C++ doesn't know about threads
(you should know this already)
Click to expand...

OK, but how do I access this:

class Data
{
public:
Data():plus(new long double),mult(new long double),pow(new long
double){}
SmrtPtr<long double> plus;
SmrtPtr<long double> mult;
SmrtPtr<long double> pow;
};

SmrtPtr<Data> tuple(new Data);
//how do I access the members of tuple?
 
T

Thomas J. Gritzan

Protoman said:
Thomas said:
Protoman schrieb:
[ SmrtPtr said:
OK, I fixed the above, but, now I'm wondering: is SmrtPtr<T> safe to
use in a container, such as a linked list? Is it thread safe?
Click to expand...
Depends on the container, if it can be used with it.

For the standard container classes, the values have to have
value-semantics. If your smart pointer works as it should, then its safe
to use in on of them.

For thread safety: Don't ask here, since C++ doesn't know about threads
(you should know this already)
Click to expand...

OK, but how do I access this:

class Data
{
public:
Data():plus(new long double),mult(new long double),pow(new long
double){}
SmrtPtr<long double> plus;
SmrtPtr<long double> mult;
SmrtPtr<long double> pow;
};

SmrtPtr<Data> tuple(new Data);
//how do I access the members of tuple?
Click to expand...

Smart pointers usually imitate the syntax of normal pointers.

tuple->plus
tuple->mult
tuple->pow

or:

(*tuple).plus
....
 

Ask a Question

Want to reply to this thread or ask your own question?

You'll need to choose a username for the site, which only take a couple of moments. After that, you can post your question and our members will help you out.

Ask a Question

Similar Threads

Is this a good reference-counting smart pointer class? 10
Is this Smart Pointer class thread-safe? 28
Smart Pointer help 13
D-tor apparentlly isn't called here 8
Can't understand this problem with ref counting class? 8
Reference Counting 5
Does this class will make a pointer in c++ work like the reference in java 3
Eliminate second invocation of class (example_visitor) object 6

Members online

Total: 262 (members: 1, guests: 261)
Robots: 263

Forum statistics

Threads
473,961
Messages
2,570,130
Members
46,689
Latest member
liammiller

Latest Threads

Top