如何实现轻量级快速关联数组

我正在尝试了解如何实现一个为搜索操作提供恒定时间的关联数组，现在我的实现如下所示：

#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;
}
};

对此进行一个简单的测试：

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 testsn------------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 %dn", dct["key1"], dct["key2"], dct["key3"]);
printf("%d %d %dn", 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);
}

事情是这样的，现在搜索操作是线性时间，我希望它成为恒定时间，我想知道一种简单/轻量级的方法来实现这一目标。

我已经看到哈希表是一种可能的选择，但我不希望为每个对象实现哈希函数。也许类似于unordered_map...邓诺。

任何人都可以给出一些想法，或者提供我在这里试图实现的简单轻量级实现吗？

在这个虚构的例子中，我使用 std：：vector 来避免使问题比它本身更大、更复杂，但我真正的用例根本不会使用 STL(即：我将编写我自己的自定义实现 std：：vector)

约束

• 根本不使用 STL 的原因不是因为该实现不够好(快速、通用、功能齐全)，而是因为对于我的大小受限项目来说非常繁重(最终 exe <=65536bytes)。即使是STL的这个小实现实际上也很大，可以按原样使用。
• 我不需要关联数组的完整实现，而只需要提供我已经在上面实现的接口(主要问题是线性时间搜索)
• 我不在乎插入/删除方法很慢，但我绝对希望搜索/查找接近恒定时间
• 我想我需要使用哈希表在关联数组中转换上述实现，但我不确定相关的实现细节(每个对象的哈希函数，表大小......