Здравствуйте, Erop, Вы писали:

E>Здравствуйте, _hum_, Вы писали:

__>>Как проще всего организовать два неприводимых неявно друг к другу целочисленных типа.
E>оно

Автор: Erop
Дата: 29.04.08

?

Нет. Там все же про другое речь.

Здравствуйте, denisko, Вы писали:

D>Здравствуйте, _hum_, Вы писали:

D>http://en.cppreference.com/w/cpp/language/user_literal

Не совсем понимаю вашу идею использования литералов для моей проблемы. Можете пояснить?

Здравствуйте, jazzer, Вы писали:

J>Здравствуйте, _hum_, Вы писали:

S>>>BOOST_STRONG_TYPEDEF()

__>>а без буста никак? во-первых, не хочется сторонние библиотеки,а во-вторых, хочется простоты и прозрачности кода.

J>Ну скопируй конкретно это из буста, оно маленькое, особенно если тебе не нужно кучу разных компиляторов поддерживать.

Во-первых, оно не маленькое, ибо ссылается и на другие бустовские вещи типа boost::totally_ordered1,

#include <boost/config.hpp>
#include <boost/operators.hpp>

#if !defined(__BORLANDC__) || __BORLANDC__ >= 0x590
    #define BOOST_STRONG_TYPEDEF(T, D)                              \
    struct D                                                        \
        : boost::totally_ordered1< D                                \
        , boost::totally_ordered2< D, T                             \
        > >                                                         \
    {                                                               \
        T t;                                                        \
        explicit D(const T t_) : t(t_) {};                          \
        D(){};                                                      \
        D(const D & t_) : t(t_.t){}                                 \
        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
        D & operator=(const T & rhs) { t = rhs; return *this;}      \
        operator const T & () const {return t; }                    \
        operator T & () { return t; }                               \
        bool operator==(const D & rhs) const { return t == rhs.t; } \
        bool operator<(const D & rhs) const { return t < rhs.t; }   \
    };
#else
    #define BOOST_STRONG_TYPEDEF(T, D)                              \
    struct D                                                        \
        : boost::totally_ordered1< D                                \
        , boost::totally_ordered2< D, T                             \
        > >                                                         \
    {                                                               \
        T t;                                                        \
        explicit D(const T t_) : t(t_) {};                          \
        D(){};                                                      \
        D(const D & t_) : t(t_.t){}                                 \
        D & operator=(const D & rhs) { t = rhs.t; return *this;}    \
        D & operator=(const T & rhs) { t = rhs; return *this;}      \
        /*operator const T & () const {return t; }*/                \
        operator T & () { return t; }                               \
        bool operator==(const D & rhs) const { return t == rhs.t; } \
        bool operator<(const D & rhs) const { return t < rhs.t; }   \
    };
#endif // !defined(__BORLANDC) || __BORLANDC__ >= 0x590

#endif // BOOST_STRONG_TYPEDEF_HPP

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

template<typename IntegerType, int uid>
class strong_redefined
{
    static const int s_uid;

    IntegerType m_val;
public:
               strong_redefined(IntegerType val = 0):m_val(val){}
    explicit   strong_redefined(const strong_redefined& X):m_val(X.m_val){}
               strong_redefined&  operator=(const strong_redefined& X){if(this != &X){m_val = X.m_val;}; return *this;}
    
    operator IntegerType()const{return m_val;}

    strong_redefined& operator+(IntegerType i){m_val += i; return *this;}
    //....
    //<остальные операторы для типа IntegerType > 
    //....
};

template<typename IntegerType, int uid>
int strong_redefined<IntegerType, uid>::s_uid = uid;





int _tmain(int argc, _TCHAR* argv[])
{
    typedef strong_redefined<int,1> type_1;
    typedef strong_redefined<int,2> type_2;

    
    type_1 x = 10;
    type_2 u = 20;

    type_1 y = 15;

    x = u;// ошибка компиляции
    x = y;// ок
 

    return 0;
}

Но, блин, надо тогда переопределять все операции (


Странно, почему в новом стандарте сделали строгие enum-ы, а строгих определений хотя бы для базовых типов — обошли стороной...