How can a Static member function know all instances?

S

SJ

Hi:
I have a class which has a static member function. The function
implements something common to all instances.
How can the static member function know all of the (Get access to the
instances' handles) instances?

Thanks in advance for any help
 
V

Victor Bazarov

SJ said:
I have a class which has a static member function. The function
implements something common to all instances.
How can the static member function know all of the (Get access to the
instances' handles) instances?

The usual implementation is a container of instance pointers as a static
data member of a class. Make sure you add to that list in every
constructor (thus you will have to re-implement all implicit ones), and
remove from that list in the destructor.

V
 
J

Jeff Schwab

SJ said:
I have a class which has a static member function. The function
implements something common to all instances.
How can the static member function know all of the (Get access to the
instances' handles) instances?

In the constructor of your class, have each instance register itself in
a static table.
 
J

John Harrison

SJ said:
Hi:
I have a class which has a static member function. The function
implements something common to all instances.
How can the static member function know all of the (Get access to the
instances' handles) instances?

Thanks in advance for any help

Something like this?

class X
{
X() { instances.insert(this); }
X(const X& rhs) { instances.insert(this); ... }
// all other ctors similarly

~X() { instances.erase(this); }

static std::set<X*> instances;
static void some_func()
{
for (std::set<X*>::const_iterator i = instance.begin(); i !=
instances.end(); ++i)
{
X* inst = *i;
// do something with inst
}
}
};

A hash table would probably be a better structure than a std::set.

One issue that occurs to me is that the compiler is allowed to optimise away
a copy constructor even if that copy constructor has a side effect. Not sure
if that is an issue here since I can't recall the circumstances in which
this is allowed to happen.

john
 
H

Howard

SJ said:
Hi:
I have a class which has a static member function. The function
implements something common to all instances.
How can the static member function know all of the (Get access to the
instances' handles) instances?

Thanks in advance for any help

It can't. Not directly, anyway. Static member functions can only access
static member data.

If you're doing something common to all instances, then that should probably
be done by manipulating static member data. Static member data is located
in one place only, not in every instance of the class, so there should be no
need to gain access to all existing instances. They all share the same
static data.

If what you're doing is manipulating some common data value, upon which
individual instances then make *other* calculations (to their own,
non-static, member data), then one solution is to use accessor functions in
the class for the non-static member data. Then, when you ask for one of
those calculated values, you can actually calculate it at that time from the
static data that the static function previously changed.

Or, if there is some reason that you *really* need to access all existing
instances of a class from a static function, then you'll need to somehow
register each instance with a container of some sort, and iterate through
the container to access those instances.

-Howard
 
B

bartek

(...)
One issue that occurs to me is that the compiler is allowed to
optimise away a copy constructor even if that copy constructor has a
side effect. Not sure if that is an issue here since I can't recall
the circumstances in which this is allowed to happen.

In case of direct RVO probably.
Shouldn't be a problem whatsoever, should it?
 
V

Victor Bazarov

John said:
[...]
One issue that occurs to me is that the compiler is allowed to optimise away
a copy constructor even if that copy constructor has a side effect. Not sure
if that is an issue here since I can't recall the circumstances in which
this is allowed to happen.

Mostly it's for return value optimization and pass-by-value optimization,
I believe.

V
 
D

David Harmon

On Thu, 20 May 2004 16:53:13 +0100 in comp.lang.c++, "John Harrison"
One issue that occurs to me is that the compiler is allowed to optimise away
a copy constructor even if that copy constructor has a side effect. Not sure
if that is an issue here since I can't recall the circumstances in which
this is allowed to happen.

The compiler is allowed to optimize away the creation of a temporary
value, even if that implies eliminating a constructor call with a side
effect. But, if the compiler finds it necessary to create the object,
then the constructor must be called. Works fine for the purpose of
registering all the objects created.
 
D

Dave Townsend

Speaking RVO , in this situation, there would be the elimination of a
destructor call too,
so the net effect is none.
 

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

Members online

No members online now.

Forum statistics

Threads
473,744
Messages
2,569,484
Members
44,903
Latest member
orderPeak8CBDGummies

Latest Threads

Top