Как я могу создать новый примитивный тип с сильными typedefs в стиле С++ 11?

Ответ 1

Есть несколько способов решить эту проблему, но поскольку я искал исправление для кода Bjarne в слайдах презентации, я принимаю этот ответ, который @robson3.14 оставил в комментариях на вопрос:

#include <iostream>

template<int M, int K, int S> struct Unit { // a unit in the MKS system
    enum { m=M, kg=K, s=S };
};

template<typename Unit> // a magnitude with a unit
struct Value {
    double val; // the magnitude
    // construct a Value from a double
    constexpr explicit Value(double d) : val(d) {} 
};

using Meter = Unit<1,0,0>; // unit: meter
using Second = Unit<0,0,1>; // unit: sec
using Speed = Value<Unit<1,0,-1>>; // meters/second type

// a f-p literal suffixed by ‘_s’
constexpr Value<Second> operator "" _s(long double d)
{
    return Value<Second> (d);
}
// a f-p literal suffixed by ‘_m’
constexpr Value<Meter> operator "" _m(long double d)
{
    return Value<Meter> (d);
}
// an integral literal suffixed by ‘_m’
constexpr Value<Meter> operator "" _m(unsigned long long d)
{
    return Value<Meter> (d);
}

template<int m1, int k1, int s1, int m2, int k2, int s2>
Value<Unit<m1 - m2, k1 - k2, s1 - s2>> operator / (Value<Unit<m1, k1, s1>> a, Value<Unit<m2, k2, s2>> b)
{
    return Value<Unit<m1 - m2, k1 - k2, s1 - s2>>(a.val / b.val);
}

int main()
{
    Speed sp1 = 100_m / 9.8_s;
    std::cout << sp1.val;
}

Ответ 2

В С++ 11 нет сильных typedef. Существует поддержка единиц с <chrono>, но это совершенно другая вещь. Никто не может договориться о том, какое поведение должны иметь сильные typedefs, так что никогда не было предложений для них, которые попали куда угодно, поэтому они не только не являются ни С++ 11, ни С++ 14, нет реальной перспективы в этом время, когда они попадут в любой будущий Стандарт.

Ответ 3

Компиляторы С++ обычно ожидают вариант командной строки -std=c++11 (или -std=c++0x для более старых, соответственно) для активации поддержки С++ 11.

не поддерживает стиль С++ 11 вообще.

Нет, это прекрасно. Поддержка GCC 4.7.2 может быть отмечена здесь. Чтобы активировать некоторые экспериментальные функции, пройдите -std=gnu++11.

И Clang 3.4 фактически поддерживает практически все в С++ 11 и уже много из С++ 1y.

Ответ 4

Не уверен, что это то, чего ты хочешь, он уродлив, но он работает:) Вы можете обернуть тип в класс шаблона,

template <typename T, int N> // N is used for tagging
struct strong_typedef
{
    using strong_type = strong_typedef<T,N>; // typedef for the strong type
    using type = T; // the wrapped type
    T value; // the  wrapped value

    strong_typedef(T val): value(val){}; // constructor
    strong_typedef(){value={};}; // default, zero-initialization

    // operator overloading, basic example: 
    strong_type& operator+(const strong_type& rhs)
    {
        value+=rhs.value; 
        return *this;
    }

    // display it
    friend ostream& operator<<(ostream & lhs, const strong_typedef& rhs)
    {
        lhs << rhs.value;
        return lhs;
    }
};

затем используйте его как

// these are all different types
strong_typedef<double, 0> x = 1.1; 
strong_typedef<double, 1> y = 2.2;
strong_typedef<double, 2> z = 3.3;

std::cout << x + x << std::endl; // outputs 2.2, can add x and x
// cout << x + y << endl; // compile-time ERROR, different types

x, y и z теперь три разных типа из-за разных N -s, используемых в шаблоне. Вы можете получить доступ к типу и значению с помощью полей type и value, например x::value (будет double 1.1). Конечно, если вы прямо typedef struct_typedef::type, вы вернетесь к квадрату, так как теряете тип strong. Поэтому в основном ваш тип должен быть strong_typedef, а не strong_typedef::type.

Ответ 5

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

Для моего проекта Arduino у меня есть такие типы, как

template <typename T>
struct millisecond {
    T millisecond;
    static constexpr const struct millisecond<T> zero = { 0 };
};

template <typename T>
struct microsecond {
    T microsecond;
    static constexpr const struct microsecond<T> zero = { 0 };
};

и использовать как

auto time_diff = millisecond<unsigned long>::zero;
time_diff.millisecond = nowMilliseconds() - s_lastPollTime.millisecond;

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

total_expenses.euros = expence1.euros + expence2.dollars;