Re: STL map, compare function
S S wrote:
On Jun 23, 7:19?pm, Kai-Uwe Bux <jkherci...@gmx.net> wrote:
S S wrote:
Hi
I have a requirement where I am declaring a map within a class.
class abc {
map <void*, void*> mMap; // I do not pass compare struct here.
...
};
Here I am not passing compare function, but I want to do it into the
constructor of class abc. Is it possible?
No. You have to specify the type of the comparison object beforehand.
If you look for STL map's function, it says a constructor like,
map(const key_compare& k)
Not sure what it is for..
It is for creating a map that uses k as the comparison predicate for keys.
However, that does not change the fact that the type key_compare has to be
specified beforehand. The map template takes up to four type parameters.
The third is the comparison predicate. So
map< key_type, mapped_type, key_compare >
is what you need. (The fourth argument would be the type for an allocator.)
Above void* could well be
char* and in that case user will initialize it with some char compare
function , but I don't know how to accomplish above task.
Sounds like a bad idea. But anyway, ?you can use tr1::function, somewhat
like so:
typedef tr1::function< bool(void*,void*) > void_ptr_compare;
map< void*, void*, void_ptr_compare > mMap;
Now, you can initialize mMap from anything that can be used to compare
void*.
Can I do something like
abc::abc() : mMap(compare_string) {}
But above dosen't work !!
Well, that would depend on many things (including the meaning of
compare_string).
So I want to try something like function pointers, see the code below
bool comp_default(const void *a, const void *b) { return ?a < b; }
bool CharStringCompare(const void* a, const void* b) {return
strcmp((char*)a, (char*)b) < 0;}
struct compare_key_ {
bool operator()(const void* a, const void* b)
{
return (abc::*mComp)(a, b); // I know this is wrong as I am not
using object here
}
};
Make the function pointer a member of compare_key_ and pass it upon
construction of compare_key_.
This wont help probably as I need to let mComp point differently
depending on each 'abc' object.
And your point is? So, abc looks like so:
class abc {
map< void*, void*, compare_key_ > mMap;
public:
abc ( ..., bool(*comparison_ptr)(void*,void*) )
: mMap( compare_key_( comparison_ptr ) )
{}
...
};
However, tr1::function is more flexible than compare_key_ anyway.
class abc {
friend struct compare_key_;
bool (abc::*mComp) (const void*, const void*) ;
map<void*, void*, compare_key_> mMap;
...
};
But above code is not the correct thing I am doing, I just wanted to
let you know the direction I am thinking? Can someone please help me
out.
You seem to be headed the wrong direction. What is the underlying problem
you are trying to solve. Very likely, the use of void* is already a
mistake
I am trying to create a HashTable class (a hash implementation), here
I am using void*, it can store pointers / integers / char* /
anything....
No need for void*. Make your hash table a template.
template < typename KeyType, typename MappedType, typename HashFct >
class hash_table {
public:
hash_table( HashFct const & f = HashFct() );
void insert( KeyType const & key, MappedType const & value );#
...
};
It is to be used as follows:
hash_table< int, int, IntHash >
One could even go on and provide a default for HastFct that has
specializations for built-in types and other bells and whistles.
BTW: you could just use the hash table from the upcoming standard.
tr1::unordered_map might be more or less what you are looking for.
Best
Kai-Uwe Bux