Создание идентификационного номера на основе типа в старом коде с минимальными изменениями

Я поддерживаю очень старую (20+ лет) и довольно большую (15 KLOC) библиотеку, в которой есть различные типы объектов, которые в настоящее время идентифицируются целым числом. Это ставит проблему, что только учитывая целое число, я не могу знать, какой тип объекта он должен идентифицировать. Это было бы здорово сделать во время компиляции.

Решение, которое я предложил с минимальными изменениями, состояло в том, чтобы создать шаблон идентификатора и затем создать для него typedef для различных типов идентификаторов объектов.

Я понял, что мне нужно добавить третий параметр в шаблон, так как два абсолютно разных идентификатора могут иметь одинаковый базовый тип и диапазон.

Я нашел C ++ не считает

typedef int X;
typedef int Y;

Как совершенно разные типы.

Это решение: —

А) разумно (я знаю, что это работает)

Б) Есть ли еще один простой способ сделать это — руководство боится больших изменений LOC

Упрощение решения только с примером оператора.

#include <iostream>

// Horrible old definition of current code
class OldObjectA
{
public:
int ident_; // int identifier
int uniq_;  // another int identifier unique to OldObjectA's only
};

class OldObjectB
{
public:
int ident_;
int next_; // int of another OldObjectB ident_
int uniq_; // another int identifier unique to OldObjectB's only
int dq_;   // int of yet anothera OldObjectB ident_
int com_;  // int of ident_ of a OldObjectA
int ld_;   // int of ident_ of a OldObjectC
};

class OldObjectC
{
public:
int indent_;
int next_; // int of another OldObjectC ident_
int com_;  // int of ident_ of a OldObjectA
};

enum Type { TypeA, TypeAU, TypeB, TypeBU, TypeC };

template<class T, T maxval, Type type>
class ID
{
public:
friend bool operator==(const ID<T, maxval, type> &lhs, const ID<T, maxval, type> &rhs)
{
std::cout << __PRETTY_FUNCTION__ << std::endl;
return true;
}
};

typedef ID<int, 42, TypeA>  ID_A;
typedef ID<int, 42, TypeAU> ID_UniqA;
typedef ID<int, 42, TypeB>  ID_B;
typedef ID<int, 42, TypeBU> ID_UniqB;
typedef ID<int, 100, TypeC> ID_C;

// What I was thinking of doing
class NewObjectA
{
public:
ID_A ident_; // int identifier
ID_UniqA uniq_;  // another int identifer
};

class NewObjectB
{
public:
ID_B ident_;
ID_B next_; // int of another OldObjectB ident_
ID_UniqB uniq_; // another int
ID_B dq_;   // int of yet anothera OldObjectB ident_
ID_A com_;  // int of ident_ of a OldObjectA
ID_C ld_;   // int of ident_ of a OldObjectC
};

class NewObjectC
{
public:
ID_C indent_;
ID_C next_; // int of another OldObjectC ident_
ID_A com_;  // int of ident_ of a OldObjectA
};

int main(int argc, char *argv[])
{
std::cout << "================================================================================\n";
ID_A a,a2;
ID_UniqA au,au2;
ID_B b,b2;
ID_UniqB bu,bu2;
ID_C c,c2;

a==a2;
au==au2;
b==b2;
bu==bu2;
c==c2;

// wanted and expected compile time fails
// a=au;
// a=b;
// a=bu;
// a=c;
// au=b;
// au=bu;
// au=c;
// b=bu;
// b=c;

std::cout << "================================================================================\n";return 0;
}