Оператор перегрузки & lt; для массива длинных значений

Моя реализация оператора< Перегрузка не работает должным образом для моего класса-оболочки вокруг массива длинных значений.

При использовании этого класса-обертки для Key внутри std :: map вызов функций из / find не работает, если я смешиваю массивы различной длины.

const oid oid1[] = { 1,3,6,1,4,1,42570,1,3,1 };
oid_wrapper wrapper1(oid1, 10);
const oid oid2[] = { 1,3,6,1,4,1,42570,1,3,1,9,1 };
oid_wrapper wrapper1(oid2, 12);

При добавлении wrapper1 сначала, а затем wrapper2 на карту, он всегда найдет wrapper1 с помощью at / find, но для wrapper2 он вызывает исключение out_of_range с at и iterator.end с find.

При добавлении wrapper2 сначала, а затем wrapper1 на карту, он всегда найдет wrapper2 с помощью at / find, но для wrapper1 он вызывает исключение out_of_range с at и iterator.end с find.

Тип oid из Net-SNMP и на самом деле это unsigned long int.
Так что моя реализация отсутствует или делает совершенно неправильно?

#include <ostream>
#include <sstream>
#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

class oid_wrapper {
public:
oid_wrapper(const oid* _oid_value, int _oid_length) : oid_value(0), oid_length  (_oid_length) {
oid_value = snmp_duplicate_objid(_oid_value, oid_length);
}

const oid* get_oid() const { return oid_value; }
const int& get_length() const { return oid_length; }

/**
* copy operator overloader
*/
oid_wrapper& operator=(const oid_wrapper& wrapper) {
oid_value = snmp_duplicate_objid(wrapper.get_oid(), wrapper.get_length());
oid_length = wrapper.get_length();

return *this;
}

/**
* equal operator overloader
*/
bool operator==(const oid_wrapper& rhs) const {
const oid* rhs_oid = rhs.get_oid();
const int rhs_length = rhs.get_length();

if (netsnmp_oid_equals(oid_value, oid_length, rhs_oid, rhs_length) == 0) {
return true;
} else {
return false;
}
}

/**
* less-than operator overloader
*/
bool operator<(const oid_wrapper& rhs) const {
const oid* rhs_oid = rhs.get_oid();
const int rhs_length = rhs.get_length();

if (oid_length < rhs_length) { return true; }

for (int i = 0; i < oid_length; i++) {
if (oid_value[i] < rhs_oid[i]) { return true; }
}

return false;
}

const long getLastNumberInOid() const { return oid_value[oid_length - 1]; }

bool operator!=(const oid_wrapper& rhs) { return !operator==(rhs); }
bool operator>(const oid_wrapper& rhs) { return !operator<(rhs); }
bool operator<=(const oid_wrapper& rhs) { return !operator>(rhs); }
bool operator>=(const oid_wrapper& rhs) { return !operator<(rhs); }

private:
const oid* oid_value;
int oid_length;
};

Это мой тестовый класс, который я разработал, чтобы проверить, работает ли он:

#include <iostream>
#include <ostream>
#include <string>
#include <map>
#include <stdexcept>

#include <net-snmp/net-snmp-config.h>
#include <net-snmp/net-snmp-includes.h>

#include "oid_wrapper.h"
using namespace std;

int main(int argc, char **argv) {

cout << "Testing first set of OID" << endl;
const oid oid1[] = { 1,3,6,1,4,1,40850,1,3 };
const oid_wrapper parent1 (oid1, 9);
const oid_wrapper parent1_child1 (parent1, 40);
const oid_wrapper parent1_child2 (parent1, 41);
const oid_wrapper parent1_child3 (parent1, 42);
const oid_wrapper parent1_child4 (parent1, 43);

map<oid_wrapper, string> test;
test.insert(make_pair(parent1_child1, "parent1_child1"));
test.insert(make_pair(parent1_child2, "parent1_child2"));
test.insert(make_pair(parent1_child3, "parent1_child3"));
test.insert(make_pair(parent1_child4, "parent1_child4"));
if (test.size() != 4) { cout << "FAIL" << endl; }
cout << "Number of OID in list: " << test.size() << endl;

const oid_wrapper parent11 (oid1, 9);
const oid_wrapper parent1_child11 (parent11, 40);
try {
string teststring = test.at(parent1_child11);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child12 (parent11, 41);
try {
string teststring = test.at(parent1_child12);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child13 (parent11, 42);
try {
string teststring = test.at(parent1_child13);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child14 (parent11, 43);
try {
string teststring = test.at(parent1_child14);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

cout << "Testing second set of OID" << endl;
const oid oid2[] = { 1,3,6,1,4,1,40850,2,1,9,1 };
const oid_wrapper parent2 (oid2, 11);
const oid_wrapper parent2_child1 (parent2, 1);
const oid_wrapper parent2_child2 (parent2, 2);
const oid_wrapper parent2_child3 (parent2, 3);
const oid_wrapper parent2_child4 (parent2, 4);

test.insert(make_pair(parent2_child1, "parent2_child1"));
test.insert(make_pair(parent2_child2, "parent2_child2"));
test.insert(make_pair(parent2_child3, "parent2_child3"));
test.insert(make_pair(parent2_child4, "parent2_child4"));
if (test.size() != 8) { cout << "FAIL" << endl; }
cout << "Number of OID in list: " << test.size() << endl;

const oid_wrapper parent21 (oid2, 11);
const oid_wrapper parent1_child21 (parent21, 1);
try {
string teststring = test.at(parent1_child21);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child22 (parent21, 2);
try {
string teststring = test.at(parent1_child22);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child23 (parent21, 3);
try {
string teststring = test.at(parent1_child23);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

const oid_wrapper parent1_child24 (parent21, 4);
try {
string teststring = test.at(parent1_child24);
cout << "Success" << endl;
} catch (out_of_range& e) {
cout << "Failure" << endl;
}

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,1,9,1 };
const oid_wrapper wrapper(newoid, 11, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run1 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,1,9,1 };
const oid_wrapper wrapper(newoid, 11, i);

try {
string teststring = test.at(wrapper);
run1++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run1 == 100) { cout << "Run 1 Success" << endl; }
else { cout << "Run 1: " << run1 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,1,3 };
const oid_wrapper wrapper(newoid, 9, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run2 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,1,3 };
const oid_wrapper wrapper(newoid, 9, i);

try {
string teststring = test.at(wrapper);
run2++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run2 == 100) { cout << "Run 2 Success" << endl; }
else { cout << "Run 2: " << run2 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 10; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2 };
const oid_wrapper wrapper(newoid, 8, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run3 = 0;
for (int i = 0; i < 10; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2 };
const oid_wrapper wrapper(newoid, 8, i);

try {
string teststring = test.at(wrapper);
run3++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run3 == 10) { cout << "Run 3 Success" << endl; }
else { cout << "Run 3: " << run3 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,2,5,1 };
const oid_wrapper wrapper(newoid, 11, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run4 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,2,5,1 };
const oid_wrapper wrapper(newoid, 11, i);

try {
string teststring = test.at(wrapper);
run4++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run4 == 100) { cout << "Run 4 Success" << endl; }
else { cout << "Run 4: " << run4 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,3,5,2 };
const oid_wrapper wrapper(newoid, 11, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run5 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,3,5,2 };
const oid_wrapper wrapper(newoid, 11, i);

try {
string teststring = test.at(wrapper);
run5++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run5 == 100) { cout << "Run 5 Success" << endl; }
else { cout << "Run 5: " << run5 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,2,5,2 };
const oid_wrapper wrapper(newoid, 10, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run6 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,2,5,2 };
const oid_wrapper wrapper(newoid, 10, i);

try {
string teststring = test.at(wrapper);
run6++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run6 == 100) { cout << "Run 6 Success" << endl; }
else { cout << "Run 6: " << run6 << endl; }

//#################################################

//Adding 100 OIDs
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,5,2,3,5 };
const oid_wrapper wrapper(newoid, 12, i);
test.insert(make_pair(wrapper, "wrapper"));
}

//Query for the 100 added OIDs
int run7 = 0;
for (int i = 0; i < 100; i++) {
const oid newoid[] = { 1,3,6,1,4,1,40850,2,5,2,3,5 };
const oid_wrapper wrapper(newoid, 12, i);

try {
string teststring = test.at(wrapper);
run7++;
} catch (out_of_range& e) {
//FAIL
}
}
if (run7 == 100) { cout << "Run 7 Success" << endl; }
else { cout << "Run 7: " << run7 << endl; }
}