By using this site, you agree to our updated Privacy Policy and our Terms of Use. Manage your Cookies Settings.
446,234 Members | 1,941 Online
Bytes IT Community
+ Ask a Question
Need help? Post your question and get tips & solutions from a community of 446,234 IT Pros & Developers. It's quick & easy.

How can a Static member function know all instances?

P: n/a
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
Jul 22 '05 #1
Share this Question
Share on Google+
8 Replies


P: n/a
SJ wrote:
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.
Jul 22 '05 #2

P: n/a
SJ wrote:
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
Jul 22 '05 #3

P: n/a

"SJ" <np****@hotmail.com> wrote in message
news:81**************************@posting.google.c om...
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
Jul 22 '05 #4

P: n/a

"SJ" <np****@hotmail.com> wrote in message
news:81**************************@posting.google.c om...
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
Jul 22 '05 #5

P: n/a
"John Harrison" <jo*************@hotmail.com> wrote in
news:2h************@uni-berlin.de:

(...)
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?

--
:: bartekd [at] o2 [dot] pl

Jul 22 '05 #6

P: n/a
John Harrison wrote:
[...]
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
Jul 22 '05 #7

P: n/a
On Thu, 20 May 2004 16:53:13 +0100 in comp.lang.c++, "John Harrison"
<jo*************@hotmail.com> wrote,
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.

Jul 22 '05 #8

P: n/a

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

"bartek" <sp******************@o2.pl> wrote in message
news:Xn**********************************@153.19.2 51.200...
"John Harrison" <jo*************@hotmail.com> wrote in
news:2h************@uni-berlin.de:

(...)
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?

--
:: bartekd [at] o2 [dot] pl

Jul 22 '05 #9

This discussion thread is closed

Replies have been disabled for this discussion.