Hi all,

Quick question is it possible to check the amount of pointers to a pointing to a particular address. If so whats the syntax

Thanks Yogi

Are you referring to the number of pointers generated by one application (namely the one which you are in) to the address, or are you asking if you can determine the total number of pointers from all running programs to a particular point in memory?

Hi thanks for your quick responce,

Yes im referring to the number of pointers generated by one application (namely the one which you are in) to the address.

A possible example to try to clarify wat i mean

int a = 1000;
int *p;
int *q;

p = &a;
q = &a;

So the number of pointers to a is 2;
Thanks Yogi

There is no built in mechanism for that in C/C++, but search for the "smart pointer" concept if you need it badly.

Thanks, think the counted_ptr.h should do the job exactly.

Hey I don't have that header file.
Can you post it here?

Sure i found it off the following website

http://ootips.org/yonat/4dev/smart-pointers.html

Haven't had a chance to implement it though.

here is the 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

/* For ANSI-challenged compilers, you may want to #define
* NO_MEMBER_TEMPLATES or explicit */

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;
}

#ifndef NO_MEMBER_TEMPLATES
template <class Y> friend class counted_ptr<Y>;
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;
}
#endif // NO_MEMBER_TEMPLATES

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© {}
X* ptr;
unsigned count;
}* itsCounter;

void acquire(counter* c) throw()
{ // increment the count
itsCounter = c;
if © ++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 // COUNTED_PTR_H

Great.
Thanks.