Assigning Unique ID's to each instance of a class - c++

Question

I am importing items from an XML file. Each XML element (FoodItem, Person, Order, CoffeeRun) is a class & each of these elements will have a unique ID(unique to that class).
<person>
<id>0</id>
<name>...</name>
</person>
<FoodItem>
<id>0</id>
<name>Coffee</name>
</FoodItem>
I am trying to develop a sub class DatabaseItem, that ensures that no 2 objects of a class have the same ID. Can you assist me, by helping me develop an efficient algorithm that makes sure no object will have the same ID as another?
My 2 approaches seem a little inefficient to me:
Use a static class vector that contains all the USED ids so far. When a new DatabaseID( int requestedID ) object is created I check whether the ID is available by going over all the used values in the vector to check the ID is not already there, I think thats Big-O'n speed?
Use a static class bool vector where each element of the vector corresponds to an id (so vector[1] will correspond to the object with ID 1). I check if an ID is already taken by seeing if that element in the vector is true if ( v[nID] == true ) { // this ID is already taken }. This seems inefficient because it means my vector will take a lot of memeory right?
I am not familiar with using maps in C++ but maybe I should use one here?
Any advice on an efficient algorithm would be really helpful:
class DatabaseItem
{
public:
static unsigned int instanceCount;
DatabaseItem()
{
// Assign next available ID
}
DatabaseItem( unsigned int nID )
{
// Check that that id is not already taken
// if id is taken, look for next available id &
// give the item that id
}
private:
unsigned int uniqueID;
};
// My solution: Do you have any better ideas that ensure no objects jave the same ID?
// This seems REALLY inefficient...
class DatabaseItem
{
public:
static unsigned int instanceCount;
static vector <unsigned int> usedIDs;
DatabaseItem()
{
DatabaseItem::instanceCount++;
uniqueID = instanceCount;
usedIDs.add( instanceCount );
}
DatabaseItem( unsigned int nID )
{
if ( isIDFree( nID ) )
{
uniqueID = nID;
}
else uniqueID = nextAvailableID();
DatabaseItem::instanceCount++;
}
bool isIDFree( unsigned int nID )
{
// This is pretty slow to check EVERY element
for (int i=0; i<usedIDs.size(); i++)
{
if (usedIDs[i] == nID)
{
return false;
}
}
return true;
}
unsigned int nextAvailableID()
{
while ( true )
{
unsigned int ID = 0;
if ( isIDFree( ID ) )
{
return ID;
}
else ID++;
}
}
private:
unsigned int uniqueID;
};
// Alternate that uses boolean vector to track which ids are occupied
// This means I take 30000 boolean memory when I may not need all that
class DatabaseItem
{
public:
static unsigned int instanceCount;
static const unsigned int MAX_INSTANCES = 30000;
static vector <bool> idVector;
// Is this how I initialise a static class vector...? (note this code will be outside the class definition)
// vector <bool> DatabaseItem::idVector( MAX_INSTANCES, false );
DatabaseItem()
{
uniqueID = nextAvailableID();
idVector[uniqueID] = true;
}
DatabaseItem( unsigned int nID )
{
if ( nID >= MAX_INSTANCES )
{
// not sure how I shd handle this case?
}
if ( idVector[nID] == false )
{
uniqueID = nID;
idVector[nID] = true;
}
else
{
uniqueID = nextAvailableID();
idVector[uniqueID] = true;
}
instanceCount++;
}
unsigned int nextAvailableID()
{
for (int i=0; i<idVector.size(); i++)
{
if ( !idVector[i] )
{
return i;
}
}
return -1;
}
bool isIDFree( unsigned int nID )
{
// Note I cannot do this: Because I am using Mosync API & it doesn't support any C++ exceptions'
// I declare idVector with no size! so not idVector( 30000, false)... just idVector;
// then I allow an exception to occur to check if an id is taken
try
{
return idVector[nID];
}
catch (...)
{
return true;
}
}
private:
unsigned int uniqueID;
};

Answer 1

A vector<bool> is implemented with one bit per bool, so it's not wasting as much space as you assume.
A set<unsigned int> is the easy solution to this. A vector<bool> is faster. Both could use a bit of memory. Depending on your usage patterns, there's a few other solutions:
An unsigned int all_taken_upto_this; combined with a set<int> covering all the oddball ID's that are higher than all_taken_upto_this - remove from set and increase the counter when you can.
A map<unsigned int, unsigned int> which is logically treated as begin,end of either taken or free sequences. This'll take a little fiddling to implement correctly (merging consecutive map elements when you add the last ID in between two elements e.g.)
You could probably use a premade "sparse bitset" type data structure - I don't know any implementations OTOH.

Answer 2

Depending on the number of elements and a couple other issues, you might consider actually storing them (or at least pointers to them) in a map. That would be rather simple to implement, but will take some space. On the other hand, it will provide you with fast lookup by id which might be a clear advantage if there are cross references in the XML. The map (assuming pointers) would look like:
std::map<int, std::shared_ptr<Object> > id_map;
std::shared_ptr<Object> p( new Object( xml ) );
if ( !id_map.insert( std::make_pair( p->id, p ) ).second ) {
// failed to insert, the element is a duplicate!!!
}

Answer 3

If you are not locked into using an integer you may look into GUIDs (Global Unique IDs). Depending on which platform you are using you can generally find a couple of utility functions to dynamically generate a GUID. If using Visual Studio, I've used the CoCreateGuid function.
If you are locked into a 32-bit integer another option option is a hash table. If each XML element is unique, then a hashing function could generate a unique hash value. Depending on the size of your data set there is still a small probability of collision. The one I've used that seems to have a pretty low collision rate with the data set that I've worked with is called the Jenkins hash function