Обвертка для встроенных типов

[220Volt]

Есть ли такой механизм:

typedef int t_1;
typedef int t_2;
void fn(t_1) {}
int main()
{
   t_1 ti_1;
   t_2 ti_2;
   fn(ti_1);	// ok
   fn(ti_2);	// error
   return 0;
}

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

[Abstraction]

Оно?
В предложенном решении, правда, используется не STL, а Boost. С другой стороны, если Вы им ещё не пользуетесь, стоит срочно начать.

[220Volt]

Похоже оно, спасибо, буду разбираться.

Честно говоря, надеялся, что и это будет запрещено:

#include <boost\serialization\strong_typedef.hpp>
BOOST_STRONG_TYPEDEF(int, i1)
BOOST_STRONG_TYPEDEF(int, i2)

int main()
{
	i1 val1;
	i2 val2;
	val1 = val2; // ok
}

Т.е. отсутствие operator=(base_type), только explicit конструктор. Иначе говоря перегрузка всех операторов, а не приведение к базовому типу.

[waleri]

Ну так сделайте сами - там макрос на 10 строчек...

[220Volt]

Сообщение от waleri

Ну так сделайте сами - там макрос на 10 строчек...

У меня получилось около 140 )) (перегрузка операторов.)

Сообщение от 220Volt

Честно говоря, надеялся, что и это будет запрещено:

#include <boost\serialization\strong_typedef.hpp>
BOOST_STRONG_TYPEDEF(int, i1)
BOOST_STRONG_TYPEDEF(int, i2)

int main()
{
	i1 val1;
	i2 val2;
	val1 = val2; // ok
}

Т.е. отсутствие operator=(base_type), только explicit конструктор. Иначе говоря перегрузка всех операторов, а не приведение к базовому типу.

Хотя, наверное, в таком случаи нарушится работа каких-нибудь библиотек. Видимо функциональность большая чем BOOST:strong_typedef не нужна.

[waleri]

Сообщение от 220Volt

У меня получилось около 140 )) (перегрузка операторов.)

Тогда сделайте класс-шаблон а макрос будет делать класс-наследник этого шаблона... Кроме того, если класс имеет operator type&() тогда операторы не надо перегружать.

[220Volt]

Это по сути и есть typedef из boosta, я уже определился, использую вышеназванную библиотеку, не хочу заново велосипед делать.

[waleri]

Ну, вы же жаловались, что что-то там не так, как вам надо... если их велосипед вас устраивает...

[220Volt]

Сообщение от waleri

Ну, вы же жаловались, что что-то там не так, как вам надо... если их велосипед вас устраивает...

Как реализовать я знаю, даже сделал, но слишком много творчества в таком варианте и подозреваю, что возможны конфликты с библиотеками.
Если интересно, вот что получилось + демонстрация поведения (особо не тестил, возможны ошибки):

template <typename _Ty, typename _Val>
	class Base_type_wrap
	{
		_Val value;
	public:
		explicit Base_type_wrap(_Val value): value(value) {}
		Base_type_wrap(void) {}
		~Base_type_wrap(void) {}
		operator _Val&()	{ return this->value; }
		operator const _Val&()const	{ return this->value; }
		_Ty &operator++()	{ ++this->value; return *(_Ty*)this; }
		_Ty &operator--()	{ --this->value; return *(_Ty*)this; }
		_Ty operator++(int)	
		{
			_Ty ret(*this);
			++this->value; 
			return ret;
		}
		_Ty operator--(int)	
		{
			_Ty ret(*this);
			--this->value; 
			return ret;
		}
		_Ty operator-()
		{
			_Ty ret(*this);
			ret.value = -ret.value;
			return ret;
		}
		_Ty operator+()
		{
			_Ty ret(*this);
			ret.value = +ret.value;
			return ret;
		}
		_Ty operator!()
		{
			_Ty ret(*this);
			ret.value = !ret.value;
			return ret;
		}
		_Ty operator~()
		{
			_Ty ret(*this);
			ret.value = ~ret.value;
			return ret;
		}
		_Ty operator*(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value *= out.value;
			return ret;
		}
		_Ty operator/(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value /= out.value;
			return ret;
		}
		_Ty operator%(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value %= out.value;
			return ret;
		}
		_Ty operator+(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value += out.value;
			return ret;
		}
		_Ty operator<<(int shift)
		{
			_Ty ret(*this);
			ret.value = ret.value<<shift;
			return ret;
		}
		_Ty operator>>(int shift)
		{
			_Ty ret(*this);
			ret.value = ret.value>>shift;
			return ret;
		}
		bool operator<(const _Ty &out)	{ return(this->value < out.value); }
		bool operator<=(const _Ty &out)	{ return(this->value <= out.value); }
		bool operator>(const _Ty &out)	{ return(this->value > out.value); }
		bool operator>=(const _Ty &out)	{ return(this->value >= out.value); }
		bool operator==(const _Ty &out)	{ return(this->value == out.value); }
		bool operator!=(const _Ty &out)	{ return(this->value != out.value); }
		_Ty operator&(const _Ty &out) 
		{
			_Ty ret(*this);
			ret.value &= out.value;
			return ret;
		}
		_Ty operator^(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value ^= out.value;
			return ret;
		}
		_Ty operator|(const _Ty &out)
		{
			_Ty ret(*this);
			ret.value |= out.value;
			return ret;
		}
		bool operator&&(const _Ty &out)	{ return(this->value && out.value); }
		bool operator||(const _Ty &out)	{ return(this->value || out.value); }
		_Ty &operator+=(const _Ty &out) { this->value += out.value; return *(_Ty*)this; }
		_Ty &operator-=(const _Ty &out) { this->value -= out.value; return *(_Ty*)this; }
		_Ty &operator*=(const _Ty &out) { this->value *= out.value; return *(_Ty*)this; }
		_Ty &operator/=(const _Ty &out) { this->value /= out.value; return *(_Ty*)this; }
		_Ty &operator%=(const _Ty &out) { this->value %= out.value; return *(_Ty*)this; }
		_Ty &operator<<=(int shift) { this->value <<= shift; return *(_Ty*)this; }
		_Ty &operator>>=(int shift) { this->value >>= shift; return *(_Ty*)this; }
		_Ty &operator&=(const _Ty &out) { this->value %= out.value; return *(_Ty*); }
		_Ty &operator^=(const _Ty &out) { this->value ^= out.value; return *(_Ty*)this; }
		_Ty &operator|=(const _Ty &out) { this->value |= out.value; return *(_Ty*)this; }
	};

#define MY_TYPEDEF(base_type, name)										\
	class name : public Base_type_wrap<name, base_type>					\
	{																	\
	public:																\
		name(void) {}													\
		explicit name(base_type value): Base_type_wrap(value) {}		\
	};

	MY_TYPEDEF(int, type_1)
	MY_TYPEDEF(int, type_2)

	void fn(type_1 &) {}
        void fn2(int &) {}

int main()
{
	type_1 t1(4), t11;
	type_2 t2(2), t22;
	t2 ++;				// ok
	t22 = t2 ++;		// ok
	t22 = -- t2;		// ok
	t11 = t1 <<= 3;		// ok
	fn(t1);				// ok
	fn(t2);				// error
	t1 = t2;			// error          boost::strong_typedef так не может
        t1 = type_1(t2);	        // ok
	fn2(t2);			// ok

	return 0;
}