Jump to content

  • Log In with Google      Sign In   
  • Create Account


Assigning special number to each class type at compile time


Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.

  • You cannot reply to this topic
8 replies to this topic

#1 lride   Members   -  Reputation: 633

Like
0Likes
Like

Posted 08 March 2013 - 09:09 PM

I want to assign a special number to class type at compile time.

The special number should be incremental (starting from 0 and increasing by 1 by each class type)

For example

 

class Base
{
   virtual int getSpecialNum();
}

class A : public Base{};
class B : public Base{};
class C : public Base{};
class D : public Base{};

 

 

 All A objects should return 0

All B objects should return 1

All C Objects should return 2 and so on..

 

 

I don't know how to accomplish this. Do I need some template tricks?


An invisible text.

Sponsor:

#2 RulerOfNothing   Members   -  Reputation: 1148

Like
0Likes
Like

Posted 08 March 2013 - 11:16 PM

Not really. You just need:

class Base
{
   virtual int getSpecialNum();
};

class A : public Base
{
   int getSpecialNum(){return 0;}
};

class B: public Base
{
   int getSpecialNum(){return 1;}
}

although it has been a while since I've had to do this.



#3 Hodgman   Moderators   -  Reputation: 27622

Like
1Likes
Like

Posted 08 March 2013 - 11:56 PM

If you're getting the number via a virtual function, does it really have to be known at compile time?

#4 0r0d   Members   -  Reputation: 797

Like
4Likes
Like

Posted 09 March 2013 - 02:08 AM

I don't know how to accomplish this. Do I need some template tricks?

 

You could do it with virtual functions, or if you dont want virtual functions at all then you can do like this with templates:

 

template <int N> 
class Base
{
public:
	int getSpecialNum(void){ return N; }
};

class A : public Base<0>{};
class B : public Base<1>{};
class C : public Base<2>{};
class D : public Base<3>{};

Edited by 0r0d, 09 March 2013 - 02:09 AM.


#5 _for_science   Members   -  Reputation: 500

Like
3Likes
Like

Posted 09 March 2013 - 09:19 AM

Of course, you could go all fancy and generate these unique class IDs automatically using template magic! *Applause*

You want to write your classes, and you don't want to manually assign a unique id to each one of them. Luckily you can make your compiler do the class counting. First you'll need a Base class with a static variable that counts your classes:

class Base {

public:
  // Virtual function to get the unique class id (special number)
  virtual int getUniqueClassId(void) const = 0;
  
private:
  // This static variable counts your classes (it exists exactly once in the entire program)
  static int uid_count;
};


Next you'll need a "SpecialBase" class. A class that exists between your actual class and your base class. Via template magic, this class will automatically do the counting for you. In order for this to work, we use a basic template feature. Your compiler does not consider a class with template parameter a single class. SpecialBase<A> and SpecialBase<B> are considered completely separate classes that just happen to use the same code. So if your SpecialBase class were to have a static variable, that variable would be created once for each specialized class you use in your program.

You can use that to create the following:

template <class SpecialClass>
class SpecialBase : public Base {

public:
  // This function gives you the unique class id of an object
  int getUniqueClassId(void) const { return getUniqueClassIdStatic(); }

  // This function gives you the unique class id
  static int getUniqueClassIdStatic(void) {
    if (uid >= Base::uid_count)   // If the unique id is invalid...
      uid = Base::uid_count++;    // ... set the id and increment uid_count
    return uid;
  }
  
private:
// This static variable is your classes unique id (it exists once for
// each of your classes)
  static int uid;
};

// Initialize the unique id to an invalid value
template <class SpecialClass> int SpecialBase<SpecialClass>::uid = INT_MAX;

There now exists a static uid variable for each variation of the SpecialBase class and they are all initialized to INT_MAX.
The first time anyone asks for the unique class id (by calling getUniqueClassId(), or getUniqueClassIdStatic(), a new unique id is created, based on the current uid_count we defined earlier in the Base class. The counter of the Base class (the one that exists only once in the entire program) is then incremented. Therefore, the next class that asks will automatically get a new and unique id. Keep in mind though: The order the ids are given out is based on the order they are first queried at runtime (see below for more info).

Oh and in some .cpp file somewhere you'll obviously want to initialize uid_count to zero:

#include "Base.h"
// Initialize the unique id count to 0
int Base::uid_count = 0;


How is this actually used?

// Define your classes (yep, that's all)
class A : public SpecialBase<A> { };
class B : public SpecialBase<B> { };
class C : public SpecialBase<C> { };

// Determine an object's class:
C obj;
if (obj.getUniqueId() == A::getUniqueIdStatic()) // false
  std::cout << "Object is of class A";
if (obj.getUniqueId() == B::getUniqueIdStatic()) // false
  std::cout << "Object is of class B"; 
if (obj.getUniqueId() == C::getUniqueIdStatic()) // true
  std::cout << "Object is of class C";


Note that you won't have to touch the getUniqueClassId() functions in your own code. All you have to do, is make sure that your class inherits from SpecialBase and that you use your own classes name as the template parameter. (Thus ensuring that no two classes inherit from the same specialization of SpecialBase)

Oh, but I wanted control over which class gets which index, or at least some kind of order!
Just forcibly query some ids, before doing anything else...

int main(void) {
  A::getUniqueClassIdStatic(); // A is assigned 0
  C::getUniqueClassIdStatic(); // C is assigned 1
  B::getUniqueClassIdStatic(); // B is assigned 2
  F::getUniqueClassIdStatic(); // F is assigned 3

  // your stuff...
}


I hope this helps! Depending on your project, this may be a little much. It just happened to be what I was working on recently. (And you could probably take this even further by using enums instead of static variables... but I'll just doubt that you have several million classes for these few static vars to create any performance issue)


Edited by _for_science, 09 March 2013 - 10:55 AM.


#6 lride   Members   -  Reputation: 633

Like
0Likes
Like

Posted 09 March 2013 - 10:33 AM

@0r0d: Thanks! but I need the compiler to do automatic counting

@_for_science: Thank you so much!!! That is what I was exactly looking for!


Edited by lride, 09 March 2013 - 10:38 AM.

An invisible text.

#7 lride   Members   -  Reputation: 633

Like
0Likes
Like

Posted 09 March 2013 - 12:58 PM

I think I found a simpler way using constexpr but unfortunately VC11 doesn't support it..


Edited by lride, 09 March 2013 - 12:59 PM.

An invisible text.

#8 Ryan_001   Prime Members   -  Reputation: 1220

Like
0Likes
Like

Posted 10 March 2013 - 12:11 PM

If all you need is a unique number why not use:

template <typename T> uintptr_t GetId () {
   return reinterpret_cast<uintptr_t>(&typeid(T));
   }


#9 larspensjo   Members   -  Reputation: 1526

Like
0Likes
Like

Posted 10 March 2013 - 03:53 PM

Of course, you could go all fancy and generate these unique class IDs automatically using template magic!

 

Thats is indeed the way i have seen it done elsewhere. Notice that the construction

 

class A : SpecialBase<A>

is called CRTP (curiously recurring template pattern). Follow the link and get some deeper explanation what it is about.


Current project: Ephenation.
Sharing OpenGL experiences: http://ephenationopengl.blogspot.com/




Old topic!
Guest, the last post of this topic is over 60 days old and at this point you may not reply in this topic. If you wish to continue this conversation start a new topic.



PARTNERS