000
09.11.2006, 20:38 Uhr
~derMond
Gast
|
Hallo,
ich habe eine hash_map am laufen die mir wirklich "unikate" schlüssel erstellt.
Als schlüssel benutze ich einen pointer auf einen vektor und die grösse des vektors.
Als interne daten sind mehrere vektoren etc. gespeichert...
Hier mal der Header-relevante Teil:
| C++: |
typedef unsigned int U_Int32;
typedef unsigned long long U_Int64;
typedef std::pair<double*, size_t> Key_Pair;
struct HASH_FUNCTION
{
U_Int32
operator()(const Key_Pair kp) const
{
U_Int32 ret = 0;
size_t dim = kp.second;
const double* vec = kp.first;
while(dim--)
{
ret = (ret * 31) + hash_d(*vec);
vec++;
}
return ret;
}
static inline U_Int32
hash_d(double x)
{
U_Int64* p = reinterpret_cast< U_Int64* > (&x);
return *p ^ (*p >> 32);
}
};
struct HASH_DATA
{
double* A_hat_qr;
double* tau;
double* m_k_hat;
int unit_vec_size;
int unit_vec_row;
};
typedef std::pair< Key_Pair, HASH_DATA> Hash_Pair;
class Hash
{
public:
Hash();
~Hash();
void Insert_Hash_Data(double* vec_key,
size_t size,
double* A_hat_qr,
double* tau,
double* m_k_hat,
const int unit_vec_size = -1,
const int unit_vec_row = -1);
private:
hash_map<Key_Pair, HASH_DATA, HASH_FUNCTION> m_hash_map;
};
|
Hier ist mal die Inser-Operation:
| C++: |
...
void
Hash::Insert_Hash_Data(double* vec_key,
size_t size,
double* A_hat_qr,
double* tau,
double* m_k_hat,
const int unit_vec_size,
const int unit_vec_row)
{
struct HASH_DATA hd;
hd.A_hat_qr = A_hat_qr;
hd.tau = tau;
hd.m_k_hat = m_k_hat;
hd.unit_vec_row = unit_vec_row;
hd.unit_vec_size = unit_vec_size;
const Key_Pair kp(vec_key, size);
m_hash_map.insert(Hash_Pair(kp, hd));
}
...
|
Und jetzt mal ein einfacher Test. Ich erstelle einmal einen vektor und übergebe den pointer an das hash. Jetzt wird unter diesem schlüssel der errechnet wird auch die daten gespeichert. Jetzt erstelle ich mir nochmal einen völlig identischen vektor (t) und möchte wissen ob unter diesem schlüssel schon ein eintrag drin ist. Eigentlich müsste ja "gefunden" ausgeben werden was aber nicht passiert. Seltsam ist dass die schlüssel wirklcih exakt dieselben sidn auch bei dem zweiten find aufruf - so dass er eigentlich das element finden müsste. Wenn ich statt (t) jetzt einfach zum test mal nur (v) eingebe findet er das element. Warum? Was hat denn der Pointer damit zu tun? Ich errechne mir doch nur einen schlüssel der gesucht verglichen wird mit den elementen - warum spielt denn da der pointer eine rolle?
Hier mal der testversuch:
| C++: |
Hash h;
double* A_hat = (double*)calloc(4, sizeof(double));
A_hat[0] = 0.2;
A_hat[1] = 0.5;
A_hat[2] = 0.6;
A_hat[3] = 0.44;
double* tau = (double*)calloc(1, sizeof(double));
tau[0] = 9.9;
double* m_k_hat = (double*)calloc(1, sizeof(double));
m_k_hat[0] = 1.1;
double* v = (double*)calloc(2, sizeof(double));
v[0] = 1.44;
v[1] = 1.1;
size_t size = 2;
h.Insert_Hash_Data(v, size, A_hat, tau, m_k_hat, 3,9);
hash_map<Key_Pair, HASH_DATA, HASH_FUNCTION>::const_iterator it;
double* t = (double*)calloc(2, sizeof(double));
t[0] = 1.44;
t[1] = 1.1;
size_t s = 2;
const Key_Pair kp(t, 2);
it = h.Get_Hash_Map().find(kp);
if(it == h.Get_Hash_Map().end())
std::cout << "nicht gefunden" << std::endl;
else
std::cout << "gefunden" << std::endl;
|
|
