C ++ строго типизированный typedef

Я пытался придумать способ объявления строго типизированных typedefs, чтобы поймать определенный класс ошибок на этапе компиляции. Часто бывает, что я буду вводить int для нескольких типов идентификаторов или вектора для положения или скорости:

typedef int EntityID;
typedef int ModelID;
typedef Vector3 Position;
typedef Vector3 Velocity;

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

EntityID eID;
ModelID mID;

if ( eID == mID ) // <- Compiler sees nothing wrong
{ /*bug*/ }


Position p;
Velocity v;

Position newP = p + v; // bug, meant p + v*s but compiler sees nothing wrong

К сожалению, предложения, которые я нашел для строго типизированных typedefs, включают использование boost, что, по крайней мере, для меня невозможно (по крайней мере, у меня есть c ++ 11). Поэтому, немного подумав, я натолкнулся на эту идею и хотел ею воспользоваться.

Сначала вы объявляете базовый тип как шаблон. Однако параметр шаблона ни для чего не используется в определении:

template < typename T >
class IDType
{
    unsigned int m_id;

    public:
        IDType( unsigned int const& i_id ): m_id {i_id} {};
        friend bool operator==<T>( IDType<T> const& i_lhs, IDType<T> const& i_rhs );
};

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

Затем мы определяем все члены для базового типа, просто помня, что это класс шаблона.

Наконец, когда мы хотим использовать его, мы определяем его как:

class EntityT;
typedef IDType<EntityT> EntityID;
class ModelT;
typedef IDType<ModelT> ModelID;

Типы теперь совершенно разные. Функции, которые принимают EntityID, будут выдавать ошибку компилятора, если вы, например, попытаетесь передать им ModelID. Помимо необходимости объявлять базовые типы в качестве шаблонов, со всеми вытекающими проблемами, это также довольно компактно.

Я надеялся, что у кого-нибудь были комментарии или критика по поводу этой идеи?

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

typedef float Time;
typedef Vector3 Position;
typedef Vector3 Velocity;

Time t = 1.0f;
Position p = { 0.0f };
Velocity v = { 1.0f, 0.0f, 0.0f };

Position newP = p + v*t;

С моим строго типизированным typedef мне пришлось бы сказать компилятору, что умножение скорости на Time приводит к позиции.

class TimeT;
typedef Float<TimeT> Time;
class PositionT;
typedef Vector3<PositionT> Position;
class VelocityT;
typedef Vector3<VelocityT> Velocity;

Time t = 1.0f;
Position p = { 0.0f };
Velocity v = { 1.0f, 0.0f, 0.0f };

Position newP = p + v*t; // Compiler error

Чтобы решить эту проблему, я думаю, что я должен был бы явно специализировать каждое преобразование, что может быть немного неприятно. С другой стороны, это ограничение может помочь предотвратить другие виды ошибок (скажем, умножение скорости на расстояние, возможно, что не имеет смысла в этой области). Поэтому я разрываюсь и задаюсь вопросом, есть ли у людей какие-либо мнения по поводу моей первоначальной проблемы или моего подхода к ее решению.

Это параметры фантомного типа , то есть параметры параметризованного типа, которые используются не для их представления, а для разделения разных «пространств» типов с одинаковым представлением.

И если говорить о пробелах, это полезное применение фантомных типов:

template<typename Space>
struct Point { double x, y; };

struct WorldSpace;
struct ScreenSpace;

// Conversions between coordinate spaces are explicit.
Point<ScreenSpace> project(Point<WorldSpace> p, const Camera& c) { … }

Однако, как вы видели, с типами юнитов есть некоторые трудности. Одна вещь, которую вы можете сделать, это разложить единицы в вектор целых показателей по основным компонентам:

template<typename T, int Meters, int Seconds>
struct Unit {
  Unit(const T& value) : value(value) {}
  T value;
};

template<typename T, int MA, int MB, int SA, int SB>
Unit<T, MA - MB, SA - SB>
operator/(const Unit<T, MA, SA>& a, const Unit<T, MB, SB>& b) {
  return a.value / b.value;
}

Unit<double, 0, 0> one(1);
Unit<double, 1, 0> one_meter(1);
Unit<double, 0, 1> one_second(1);

// Unit<double, 1, -1>
auto one_meter_per_second = one_meter / one_second;

Здесь мы используем фантомные значения, чтобы пометить значения времени выполнения с информацией времени компиляции об экспонентах на вовлеченных единицах. Это масштабируется лучше, чем создание отдельных структур для скоростей, расстояний и т. Д., И этого может быть достаточно, чтобы охватить ваш вариант использования.

У меня был похожий случай, когда я хотел различить различные значения некоторых целочисленных значений и запретить неявные преобразования между ними. Я написал общий класс, как это:

template <typename T, typename Meaning>
struct Explicit
{
  //! Default constructor does not initialize the value.
  Explicit()
  { }

  //! Construction from a fundamental value.
  Explicit(T value)
    : value(value)
  { }

  //! Implicit conversion back to the fundamental data type.
  inline operator T () const { return value; }

  //! The actual fundamental value.
  T value;
};

Конечно, если вы хотите быть еще более безопасным, вы также можете создать Tконструктор explicit. MeaningЗатем используются следующим образом:

typedef Explicit<int, struct EntityIDTag> EntityID;
typedef Explicit<int, struct ModelIDTag> ModelID;

Я не уверен, как это работает в производственном коде (я новичок в C ++ / программировании, например, новичок в CS101), но я сделал это с помощью макросов C ++.

#define newtype(type_, type_alias) struct type_alias { \

/* make a new struct type with one value field
of a specified type (could be another struct with appropriate `=` operator*/

    type_ inner_public_field_thing; \  // the masked_value
    \
    explicit type_alias( type_ new_value ) { \  // the casting through a constructor
    // not sure how this'll work when casting non-const values
    // (like `type_alias(variable)` as opposed to `type_alias(bare_value)`
        inner_public_field_thing = new_value; } }