How to make every derived class to return a different int

S

Stefano Sabatini

Hi all,

I'm facing this design problem.

I have a table which defines the behaviour of an Object in a given
state according to the type of event it is receiving.

So for each couple event,state I want I set in the table a different
handler.

My trivial implementation make use of defines (but I could have used
an enum as well).

So I have:
#define EVT_FOO 0
#define EVT_BAR 1
....
#define EVT_FOOBAR N

Then I define for each event a virtual GetType() which returns the
event type.

This is ugly and awkward, since everytime I add an event I have to
update the enum/list of defines, while I would like to be able to
automatically get a different integer for every derived class of
Event.

Mayeb I could get this result with some kind of run-time registration
mechanism.

I think this problem should be quite common, so I thought maybe
someone can suggest a better design than that which requires the
enum/defines list.

Regards.
 
K

Kai-Uwe Bux

Stefano said:
Hi all,

I'm facing this design problem.

I have a table which defines the behaviour of an Object in a given
state according to the type of event it is receiving.

So for each couple event,state I want I set in the table a different
handler.

My trivial implementation make use of defines (but I could have used
an enum as well).

So I have:
#define EVT_FOO 0
#define EVT_BAR 1
...
#define EVT_FOOBAR N

Then I define for each event a virtual GetType() which returns the
event type.

This is ugly and awkward, since everytime I add an event I have to
update the enum/list of defines, while I would like to be able to
automatically get a different integer for every derived class of
Event.

Mayeb I could get this result with some kind of run-time registration
mechanism.
Click to expand...

What about something like this:


unsigned int
count ( void ) {
static unsigned int c = 0;
return ( c++ );
}

struct reg_base {

virtual
unsigned int get_id ( void ) = 0;

};

template < typename D >
class reg : public reg_base {

static unsigned int const id;

public:

unsigned int get_id ( void ) {
return ( id );
}

};

template < typename D >
unsigned int const reg<D>::id = count();


struct X : public reg<X> {};
struct Y : public reg<Y> {};

#include <iostream>

int main ( void ) {
X x;
Y y1;
Y y2;
reg_base * p = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';
std::cout << "Y " << p->get_id() << '\n';
}

You could also add a static method that yields the id of a type.

I think this problem should be quite common, so I thought maybe
someone can suggest a better design than that which requires the
enum/defines list.
Click to expand...


Best

Kai-Uwe Bux
 
E

Erik Wikström

Hi all,

I'm facing this design problem.

I have a table which defines the behaviour of an Object in a given
state according to the type of event it is receiving.

So for each couple event,state I want I set in the table a different
handler.

My trivial implementation make use of defines (but I could have used
an enum as well).

So I have:
#define EVT_FOO 0
#define EVT_BAR 1
...
#define EVT_FOOBAR N

Then I define for each event a virtual GetType() which returns the
event type.

This is ugly and awkward, since everytime I add an event I have to
update the enum/list of defines, while I would like to be able to
automatically get a different integer for every derived class of
Event.

Mayeb I could get this result with some kind of run-time registration
mechanism.
Click to expand...

You could put a const int in the base-class and set it to the correct
value in the constructor of each event class.
I think this problem should be quite common, so I thought maybe
someone can suggest a better design than that which requires the
enum/defines list.
Click to expand...

It seems like you have a problem with your design. If you want to use
the number to distinguish the different events and based on that perform
different actions perhaps you should consider overloading some function
for the different event types instead.
 
P

puzzlecracker

unsigned int
count ( void ) {
  static unsigned int c = 0;
  return ( c++ );

}

struct reg_base {

  virtual
  unsigned int get_id ( void ) = 0;

};

template < typename D >
class reg : public reg_base {

  static unsigned int const id;

public:

  unsigned int get_id ( void ) {
    return ( id );
  }

};

template < typename D >
unsigned int const reg<D>::id = count();

struct X : public reg<X> {};
struct Y : public reg<Y> {};

#include <iostream>

int main ( void ) {
  X x;
  Y y1;
  Y y2;
  reg_base * p = new Y ();

  std::cout << "X " << x.get_id() << '\n';
  std::cout << "Y " << y1.get_id() << '\n';
  std::cout << "Y " << y2.get_id() << '\n';
  std::cout << "Y " << p->get_id() << '\n';

}
Click to expand...

I think it's better to eliminate count function altogether and put the
count functionality into class/struct such as, in your case, reg_base.
struct counter{

static unsigned int count getId(return id++;)

private:
static unsigned int id;

};
unsigned int counter::id=0;


Or some cleaner variation of that. I don't like member-less function
in the code. At the very least, we ought to namespace it if we're to
have this function, given that it's short to use and easier to code
than an alternative I've just mentioned.
 
H

Hendrik Schober

Stefano said:
Hi all,

I'm facing this design problem.

I have a table which defines the behaviour of an Object in a given
state according to the type of event it is receiving.

So for each couple event,state I want I set in the table a different
handler.

My trivial implementation make use of defines (but I could have used
an enum as well).

So I have:
#define EVT_FOO 0
#define EVT_BAR 1
....
#define EVT_FOOBAR N

Then I define for each event a virtual GetType() which returns the
event type.
Click to expand...

What are you doing with these event/state couples?
Could it be that what you need is multi-methods?
Have you looked into patterns? I suspect that there are much
better ways to achieve whatever you're trying to do.
This is ugly and awkward, since everytime I add an event I have to
update the enum/list of defines, while I would like to be able to
automatically get a different integer for every derived class of
Event.

Mayeb I could get this result with some kind of run-time registration
mechanism.
Click to expand...

It seems a compile-time problem, but I don't see a way to do
this at compile-time except by using vendor-specific compiler
extensions. (ISTR VC having some macro that expands to different
integers for each usage.)
I think this problem should be quite common, so I thought maybe
someone can suggest a better design than that which requires the
enum/defines list.
Click to expand...

I think so, too.
What are you trying to do with your event/state couples?

Schobi
 
K

Kai-Uwe Bux

puzzlecracker said:
I think it's better to eliminate count function altogether and put the
count functionality into class/struct such as, in your case, reg_base.
struct counter{

static unsigned int count getId(return id++;)

private:
static unsigned int id;

};
unsigned int counter::id=0;


Or some cleaner variation of that. I don't like member-less function
in the code. At the very least, we ought to namespace it if we're to
have this function, given that it's short to use and easier to code
than an alternative I've just mentioned.
Click to expand...

Yup. Also, get_id() wasn't const. Here is a cleaner version:

class reg_base {
protected:

static
unsigned int
count ( void ) {
static unsigned int c = 0;
return ( c++ );
}

public:

virtual
unsigned int get_id ( void ) const = 0;

virtual
~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

static unsigned int const the_id;

public:

unsigned int get_id ( void ) const {
return ( the_id );
}

static
unsigned int id ( void ) {
return ( the_id );
}

virtual
~reg ( void ) {}

};

template < typename D >
unsigned int const reg<D>::the_id = reg<D>::reg_base::count();


struct X : public reg<X> {};
struct Y : public reg<Y> {};

#include <iostream>

int main ( void ) {
X x;
Y y1;
Y y2;
reg_base * px = new X ();
reg_base * py = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';

std::cout << "X " << px->get_id() << '\n';
std::cout << "Y " << py->get_id() << '\n';

std::cout << "X " << X::id() << '\n';
std::cout << "Y " << Y::id() << '\n';

delete ( px );
delete ( py );
}


Best

Kai-Uwe Bux
 
S

Stefano Sabatini

You could put a const int in the base-class and set it to the correct
value in the constructor of each event class.
Click to expand...

Yes I already do that, I have a m_Type const int field in the Event
object and a GetType() which returns this type, every GetType() is
redefined for each object (for example for each Event object), so that
every one returns a different value. The problem is that I have to
rely on the enum/defines already defined, while I would like to be
able to add a new event type without the need to redefine the
enums/defines.
It seems like you have a problem with your design. If you want to use
the number to distinguish the different events and based on that perform
different actions perhaps you should consider overloading some function
for the different event types instead.
Click to expand...

Well in this case I need to redefine a different integer for every
object type, this because that index is used to access a table.
This table defines an handler to be called for each state/event
couple, that is for each event arrived I want to perform a different
action based on the state of the object.

Thanks for your help.

(I'll look at the other comments too soon).
 
S

Stefano Sabatini

What are you doing with these event/state couples?
Could it be that what you need is multi-methods?
Have you looked into patterns? I suspect that there are much
better ways to achieve whatever you're trying to do.
Click to expand...

Mmmh... do you mean something like this:
http://www.codeproject.com/KB/recipes/mmcppfcs.aspx
?

Yes I should know better patterns...
It seems a compile-time problem, but I don't see a way to do
this at compile-time except by using vendor-specific compiler
extensions. (ISTR VC having some macro that expands to different
integers for each usage.)


I think so, too.
What are you trying to do with your event/state couples?
Click to expand...

I have a table which defines for each incoming event/state the handler
to call. So I need an index for each event subtype, and I need the
number of the the events to be known when I build the table in the
constructor of the objects which defines and use that table.

Thanks for your help, regards.
 
S

Stefano Sabatini

puzzlecracker wrote: [...]
I think it's better to eliminate count function altogether and put the
count functionality into class/struct such as, in your case, reg_base.
struct counter{

static unsigned int count getId(return id++;)

private:
static unsigned int id;

};
unsigned int counter::id=0;


Or some cleaner variation of that. I don't like member-less function
in the code. At the very least, we ought to namespace it if we're to
have this function, given that it's short to use and easier to code
than an alternative I've just mentioned.
Click to expand...

Yup. Also, get_id() wasn't const. Here is a cleaner version:

class reg_base {
protected:

static
unsigned int
count ( void ) {
static unsigned int c = 0;
return ( c++ );
}

public:

virtual
unsigned int get_id ( void ) const = 0;

virtual
~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

static unsigned int const the_id;

public:

unsigned int get_id ( void ) const {
return ( the_id );
}

static
unsigned int id ( void ) {
return ( the_id );
}

virtual
~reg ( void ) {}

};

template < typename D >
unsigned int const reg<D>::the_id = reg<D>::reg_base::count();


struct X : public reg<X> {};
struct Y : public reg<Y> {};

#include <iostream>

int main ( void ) {
X x;
Y y1;
Y y2;
reg_base * px = new X ();
reg_base * py = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';

std::cout << "X " << px->get_id() << '\n';
std::cout << "Y " << py->get_id() << '\n';

std::cout << "X " << X::id() << '\n';
std::cout << "Y " << Y::id() << '\n';

delete ( px );
delete ( py );
}
Click to expand...

Yes, I tried it and it is indeed what I need. Only what I also need
would be a static method which returns the total number of objects
already registered.

But what I need most now is a crash course on templates ;-).

Thanks so much for all the help, you rock guys!!!
 
K

Kai-Uwe Bux

Stefano Sabatini wrote:
[snip]
Yes, I tried it and it is indeed what I need. Only what I also need
would be a static method which returns the total number of objects
already registered.
Click to expand...

Objects or classes?

Assuming classes, this poses an interesting problem. Here are two attempts:

a)

class reg_base {
protected:

static
unsigned int &
the_count ( void ) {
static unsigned int c = 0;
return ( c );
}

static
unsigned int count ( void ) {
return ( the_count() ++ );
}

public:

static
unsigned int num_classes ( void ) {
return ( the_count() );
}

virtual
unsigned int get_id ( void ) const = 0;

virtual
~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

static unsigned int const the_id;

public:

unsigned int get_id ( void ) const {
return ( the_id );
}

static
unsigned int id ( void ) {
return ( the_id );
}

virtual
~reg ( void ) {}

};

template < typename D >
unsigned int const reg<D>::the_id = reg<D>::reg_base::count();


struct X : public reg<X> {};
struct Y : public reg<Y> {};
struct Z : public reg<Z> {};

#include <iostream>

int main ( void ) {
std::cout << "Classes: " << reg_base::num_classes() << '\n';

X x;
Y y1;
Y y2;
reg_base * px = new X ();
reg_base * py = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';

std::cout << "X " << px->get_id() << '\n';
std::cout << "Y " << py->get_id() << '\n';

std::cout << "X " << X::id() << '\n';
std::cout << "Y " << Y::id() << '\n';

delete ( px );
delete ( py );
}


This one does not count the class Z. Honestly, I don't know the reason.


b)

class reg_base {
protected:

static
unsigned int &
the_count ( void ) {
static unsigned int c = 0;
return ( c );
}

static
unsigned int count ( void ) {
return ( the_count() ++ );
}

public:

static
unsigned int num_classes ( void ) {
return ( the_count() );
}

virtual
unsigned int get_id ( void ) const = 0;

virtual
~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

static
unsigned int & the_id ( void ) {
static unsigned int dummy = 0;
return ( dummy );
}

struct do_register {

do_register ( void ) {
the_id() = reg<D>::reg_base::count();
}

};

public:

reg ( void ) {
static do_register dummy;
}

unsigned int get_id ( void ) const {
return ( the_id() );
}

static
unsigned int id ( void ) {
return ( the_id() );
}

virtual
~reg ( void ) {}

};


struct X : public reg<X> {};
struct Y : public reg<Y> {};
struct Z : public reg<Z> {};

#include <iostream>

int main ( void ) {
std::cout << "Classes: " << reg_base::num_classes() << '\n';
X x;
std::cout << "Classes: " << reg_base::num_classes() << '\n';
Y y1;
Y y2;
std::cout << "Classes: " << reg_base::num_classes() << '\n';
Z z;
std::cout << "Classes: " << reg_base::num_classes() << '\n';
reg_base * px = new X ();
reg_base * py = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';

std::cout << "X " << px->get_id() << '\n';
std::cout << "Y " << py->get_id() << '\n';

std::cout << "X " << X::id() << '\n';
std::cout << "Y " << Y::id() << '\n';

delete ( px );
delete ( py );
std::cout << "Classes: " << reg_base::num_classes() << '\n';
}

This one counts each class, once the first object of that class has been
constructed.



I don't know, which semantics you actually need.



Best

Kai-Uwe Bux
 
E

Erik Wikström

Well in this case I need to redefine a different integer for every
object type, this because that index is used to access a table.
This table defines an handler to be called for each state/event
couple, that is for each event arrived I want to perform a different
action based on the state of the object.
Click to expand...

I seems I was not clear enough about what I meant, so perhaps an example
will do instead:

#include <iostream>

// Classes that represents the different events
struct Event { };
struct FooEvent : public Event { };
struct BarEvent : public Event { };


// Functions to handle events in state A
void stateA(const Event& e)
{
std::cout << "Generic event handler when in state A\n";
}

void stateA(const FooEvent& e)
{
std::cout << "Handler for Foo events when in state A\n";
}


int main()
{
FooEvent foo;
BarEvent bar;

stateA(foo);
stateA(bar);

return 0;
}

Using this scheme it is easy to add new events and you only have to
update the code for those states which can handle the events (by
overloading the event-handler for the new event).
 
E

Erik Wikström

I seems I was not clear enough about what I meant, so perhaps an example
will do instead:

#include <iostream>

// Classes that represents the different events
struct Event { };
struct FooEvent : public Event { };
struct BarEvent : public Event { };


// Functions to handle events in state A
void stateA(const Event& e)
{
std::cout << "Generic event handler when in state A\n";
}

void stateA(const FooEvent& e)
{
std::cout << "Handler for Foo events when in state A\n";
}


int main()
{
FooEvent foo;
BarEvent bar;

stateA(foo);
stateA(bar);

return 0;
}

Using this scheme it is easy to add new events and you only have to
update the code for those states which can handle the events (by
overloading the event-handler for the new event).
Click to expand...

I realised that you might want to be able to somehow store the state,
and I can see two ways of doing that. Either you can use create objects
for the states and overload the event handler function for both state
and event:

struct Event {};
struct FooEvent : public Event {};

struct State {};
struct BarState : public State {};


void eventHandler(const BarState& s, const Event& e)
{
// General event handler for state Bar
}

void eventHandler(const BarState& s, const FooEvent& e)
{
// Foo event handler for state Bar
}

The second alternative (which I think might be a bit more elegant) is to
make the event handlers member-functions of state-objects:


struct Event {};
struct FooEvent : public Event {};

struct State {};

struct BarState : public State
{
void handleEvent(const FooEvent& e)
{
// Handle Foo events
}

void handleEvent(const Event& e)
{
// General event handler
}
};
 
E

Erik Wikström

The second alternative (which I think might be a bit more elegant) is to
make the event handlers member-functions of state-objects:


struct Event {};
struct FooEvent : public Event {};

struct State {};

struct BarState : public State
{
void handleEvent(const FooEvent& e)
{
// Handle Foo events
}

void handleEvent(const Event& e)
{
// General event handler
}
};
Click to expand...


Actually, that won't work (remind me not to write code when I'm tired),
you would need something like double dispatch to get it to work.
 
K

Kai-Uwe Bux

Victor said:
Kai-Uwe Bux wrote: [snip]
class reg_base {
protected:

static
unsigned int &
the_count ( void ) {
static unsigned int c = 0;
return ( c );
}

static
unsigned int count ( void ) {
return ( the_count() ++ );
}

public:

static
unsigned int num_classes ( void ) {
return ( the_count() );
}

virtual
unsigned int get_id ( void ) const = 0;

virtual
~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

static unsigned int const the_id;

public:

unsigned int get_id ( void ) const {
return ( the_id );
}

static
unsigned int id ( void ) {
return ( the_id );
}

virtual
~reg ( void ) {}

};

template < typename D >
unsigned int const reg<D>::the_id = reg<D>::reg_base::count();


struct X : public reg<X> {};
struct Y : public reg<Y> {};
struct Z : public reg<Z> {};

#include <iostream>

int main ( void ) {
std::cout << "Classes: " << reg_base::num_classes() << '\n';

X x;
Y y1;
Y y2;
reg_base * px = new X ();
reg_base * py = new Y ();

std::cout << "X " << x.get_id() << '\n';
std::cout << "Y " << y1.get_id() << '\n';
std::cout << "Y " << y2.get_id() << '\n';

std::cout << "X " << px->get_id() << '\n';
std::cout << "Y " << py->get_id() << '\n';

std::cout << "X " << X::id() << '\n';
std::cout << "Y " << Y::id() << '\n';

delete ( px );
delete ( py );
}


This one does not count the class Z. Honestly, I don't know the reason.
Click to expand...

Most likely, the optimizer throws Z away (and the instantiation of the
base class as well), since it isn't used anywhere in the program. Built
without optimization with VC++ 2008 (the "Debug" configuration), the
program reports 3 classes, built optimized it reports only 2.
Click to expand...
[snip]

Hm, interesting.

That indicates, that the output is either undefined or implementation
defined. That in turn poses the question, where in the program I invoke
undefined or implementation defined behavior. Got to take a closer look; as
of now, I am quite puzzled.


Best

Kai-Uwe Bux
 
T

Triple-DES

Stefano Sabatini wrote:

[snip]
Yes, I tried it and it is indeed what I need. Only what I also need
would be a static method which returns the total number of objects
already registered.
Click to expand...

Objects or classes?

Assuming classes, this poses an interesting problem. Here are two attempts:

a)

class reg_base {
protected:

  static
  unsigned int &
  the_count ( void ) {
    static unsigned int c = 0;
    return ( c );
  }

  static
  unsigned int count ( void ) {
    return ( the_count() ++ );
  }

public:

  static
  unsigned int num_classes ( void ) {
    return ( the_count() );
  }

  virtual
  unsigned int get_id ( void ) const = 0;

  virtual
  ~reg_base ( void ) {}

};

template < typename D >
class reg : public reg_base {

  static unsigned int const the_id;

public:

  unsigned int get_id ( void ) const {
    return ( the_id );
  }

  static
  unsigned int id ( void ) {
    return ( the_id );
  }

  virtual
  ~reg ( void ) {}

};

template < typename D >
unsigned int const reg<D>::the_id = reg<D>::reg_base::count();

struct X : public reg<X> {};
struct Y : public reg<Y> {};
struct Z : public reg<Z> {};

#include <iostream>

int main ( void ) {
  std::cout << "Classes: " << reg_base::num_classes() << '\n';

  X x;
  Y y1;
  Y y2;
  reg_base * px = new X ();
  reg_base * py = new Y ();

  std::cout << "X " << x.get_id() << '\n';
  std::cout << "Y " << y1.get_id() << '\n';
  std::cout << "Y " << y2.get_id() << '\n';

  std::cout << "X " << px->get_id() << '\n';
  std::cout << "Y " << py->get_id() << '\n';

  std::cout << "X " << X::id() << '\n';
  std::cout << "Y " << Y::id() << '\n';

  delete ( px );
  delete ( py );

}

This one does not count the class Z. Honestly, I don't know the reason.
Click to expand...

I think the reason is that even if reg<Z> is implicitly instantiated
by the declaration of
struct Z : public reg<Z>, this does not cause the members of reg<Z> to
be instantiated.

Consider the following, from [temp.inst]/1: (annotations in brackets)

(...)in particular, the initialization (and any associated side-
effects) [in this case, increasing the counter] of a static data
member [of a class template] does not occur unless the static data
member is itself used in a way that requires the definition of the
static data member to exist. [never happens, since Z::the_id is never
referenced]

DP
 
H

Hendrik Schober

Stefano said:
Mmmh... do you mean something like this:
http://www.codeproject.com/KB/recipes/mmcppfcs.aspx
?
Click to expand...

Maybe. I haven't looked at this specific implementation. What
I meant was the general problem domain know as multi-methods.
If you need to call a function depending on one object's type,
in C++ you use virtual functions. If you need to pick a function
depending on the types of more than one object, then you need
multi-methods and that means in C++ you're on your own.

There are quiet a few implementations of them floating around.
IIRC, Bjarne Stroustrup's "Desgin & Evolution of C++" had a few
pages dedicated to the problem and I think one of Scott Meyer's
"(More) Effective C++" discussed it, too. (I have neither one
around here, so I can't check, but I could do so later if you
cannot find out about them otherwise.)
I suggest you read those and/or a few other discussions of the
problem to find out if that's what you need.

From what I heard about your problem so far, with just the two
objects you have, the double-dispatch idiom that Erik mentioned
might be the best solution.
Yes I should know better patterns...
Click to expand...

Read the GoF book. It's worth the while.
I have a table which defines for each incoming event/state the handler
to call. So I need an index for each event subtype, and I need the
number of the the events to be known when I build the table in the
constructor of the objects which defines and use that table.
Click to expand...

You do not necessarily need an integer-indexed table. If you
use multi-indexed maps, you can use whatever you want (well,
provided it can be ordered) to find the right method (with
'std::type_info' IMHO being a rather obvious first candidate
to look at).
Thanks for your help, regards.
Click to expand...

Schobi
 

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

How to make a div select work? 5
How to make a flex box inherit its parent (container) background. 0
How to make a iOS browser with different cookies per tab? 0
Optimal way to make a table for large lists 2
Clean ways to identify derived class types. 5
Getting derived class specific behavior explicitly 3
Problem type-casting to a derived class 9
How to make a fully functional deployable restaurant management system with c++? 0

Members online

No members online now.
Total: 2,031 (members: 1, guests: 2,030)
Robots: 108

Forum statistics

Threads
474,169
Messages
2,570,919
Members
47,460
Latest member
eibafima

Latest Threads

Top