How to implement a lightweight fast associative array? - c++

Question

I'm trying to understand how I should implement an associative array which gives constant time for search operations, right now my implementation looks like this:
#include <iostream>
#include <vector>
#include <string>
using namespace std;
template <class Key, class Value> class Dict {
private:
typedef struct Item {
Value value;
Key key;
} Item;
vector<Item> _data;
public:
void clear() {
_data.clear();
}
long size() {
return _data.size();
}
bool is_item(Key key) {
for (int i = 0; i < size(); i++) {
if (_data[i].key == key) return true;
}
return false;
}
bool add_item(Key key, Value value) {
if (is_item(key)) return false;
Item new_item;
new_item.key = key;
new_item.value = value;
_data.push_back(new_item);
return true;
}
Value &operator[](Key key) {
for (int i = 0; i < size(); i++) {
if (_data[i].key == key) return _data[i].value;
}
long idx = size();
Item new_item;
new_item.key = key;
_data.push_back(new_item);
return _data[idx].value;
}
Key get_key(long index) {
if (index < 0) index = 0;
for (int i = 0; i < size(); i++)
if (i == index) return _data[i].key;
return NULL;
}
Value &operator[](long index) {
if (index < 0) index = 0;
for (int i = 0; i < size(); i++) {
if (i == index) return _data[i].value;
}
return _data[0].value;
}
};
A simple test for this:
class Foo {
public:
Foo(int value) {
_value = value;
}
int get_value() {
return _value;
}
void set_value(int value) {
_value = value;
}
private:
int _value;
};
template <class Key, class Value> void print_dict(Dict<Key, Value> &dct) {
if (!dct.size()) {
printf("Empty Dict");
}
for (int i = 0; i < dct.size(); i++) {
printf("%d%s", dct[dct.get_key(i)], i == dct.size() - 1 ? "" : ", ");
}
printf("\n");
}
int main(int argc, char *argv[]) {
printf("\nDict tests\n------------\n");
Dict<string, int> dct;
string key1("key1");
string key2("key2");
string key3("key3");
dct["key1"] = 100;
dct["key2"] = 200;
dct["key3"] = 300;
printf("%d %d %d\n", dct["key1"], dct["key2"], dct["key3"]);
printf("%d %d %d\n", dct[key1], dct[key2], dct[key3]);
print_dict(dct);
dct.clear();
print_dict(dct);
Dict<Foo *, int> dct2;
Foo *f1 = new Foo(100);
Foo *f2 = new Foo(200);
dct2[f1] = 101;
dct2[f2] = 202;
print_dict(dct2);
}
Here's the thing, right now the search operation is linear time and I'd like it to become constant time and I'm wondering about a simple/lightweight way to achieve this.
I've seen hashtables are a possible option but I'd prefer not having to implement a hash function per object. Maybe something similar to an unordered_map... dunno.
Could anyone give some ideas or maybe providing a simple lightweight implementation of what I'm trying to achieve here?
In this fictional example I'm using std::vector to avoid making the question bigger and more complex than what it is but my the real use-case won't be using the STL at all (ie: i'll be coding my own custom implementation of std::vector)
CONSTRAINTS
The reason of not using the STL at all is not because that implementation is not good (fast,generic,full-featured) enough but more because is quite heavy for my size-constrained projects (final exe <=65536bytes). Even this small implementation of the STL is actually quite big to be used as it is
I don't need a full implementation of an associative array but just providing the interface i've already implemented above (main problem being the linear-time search)
I don't care about inserting/deleting methods being slow but definitely I'd like the search/lookup being near to constant time
I guess I'd need to convert the above implementation in an associative array using a hash table but I'm unsure about the relevant implementation details (which hash functions per object, which table size, ...)

Answer 1

Let me address some issues you've raised in your question.
Here's the thing, right now the search operation is linear time and I'd like it to become constant time and I'm wondering about a simple/lightweight way to achieve this.
A simple lightweight way to achieve this, i.e., to have an associative array (a.k.a. key-value-store), is to use one provided by the standard library.
You are coding in a recent version of C++, you are in the lucky position that the standard library actually provides one that satisfies your constant-time requirements:
http://en.cppreference.com/w/cpp/container/unordered_map
The implementation of the data structures shipped as part of a standard library of any decent compiler these days, are probably better than anything you could come up with. (Or why did you ask for give me the code?).
I've seen hashtables are a possible option but I'd prefer not having to implement a hash function per object. Maybe something similar to an unordered_map... dunno.
A std::unordered_map actually is a hash table, and as you can see in the docs, it takes a hash function. As you can see written in the docs there are lots of specializations for lots of types already available, that can help you derive a custom hash function for your custom object types:
http://en.cppreference.com/w/cpp/utility/hash
Could anyone give some ideas or maybe providing a simple lightweight implementation of what I'm trying to achieve here?
Just have a look at the example code to std::unordered_map to see how it's used. If you worry about performance, don't forget to measure. If you really want to consume some input on implementation of hash tables, I liked these talks on the Python dictionary:
https://www.youtube.com/watch?v=C4Kc8xzcA68
https://www.youtube.com/watch?v=p33CVV29OG8
Also have a look at the wikipedia page (if you haven't already):
https://en.wikipedia.org/wiki/Associative_array
In this fictional example I'm using std::vector to avoid making the question bigger and more complex than what it is but my the real use-case won't be using the STL at all (ie: i'll be coding my own custom implementation of std::vector)
Unless you are doing this for educational/recreational purposes, don't do it. Don't be ashamed to base your endeavours on the shoulders of giants. That the standard library wasn't invented in your project is not a problem.

Answer 2

If you want to keep code size small, you should avoid templates as much as possible. At least templates that create non-trivial amounts of code.
For your hash map, that means: stick to one key type and only store void pointers to the values. If you don't want to deal with void* and the casts that go along with it all over in your code, implement one non-template hash map that stores void* as value, with all "no inline" functions. Then create an "all inline" (maybe even all "force inline") wrapper class that uses the void* map internally and just converts T* <-> void*.
If you really really really need different key types, see if you can stick to PODs without padding (memcpy copyable and memcmp comparable). That way you can still use the same hash map class for everything: you just have to tell the map (at runtime) what the key-size is. Then you can copy the keys into the map using memcpy, compare using memcmp and hash them using any hash algorithm that can hash byte sequences (=almost every hash algorithm).
Of course you'll also want to do a lot of other stuff, e.g. avoid inlining any non-trivial functions, avoid C-Runtime library functions, disable exception handling and RTTI etc., but that's a different topic.
Or, maybe just stick to plain C :)