Индекс по типу - C/C++

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

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

Набросок давно лежит рядом

проверка здесь

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

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

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

BFE>Набросок давно лежит рядом

BFE>проверка здесь

да, прием интересный, но все равно еще же и морока с реализацией

cast_to_fundamental_type(fundamental_type_id, val)

будет.

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

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

BFE>>Набросок давно лежит рядом
BFE>>проверка здесь

__>да, прием интересный, но все равно еще же и морока с реализацией
__>

__>cast_to_fundamental_type(fundamental_type_id, val)
__>

__>будет.

Вы уж определитесь с набором операций и требований, а то складывается впечатление, что вы сами не знаете, чего вам надо:

#include <iostream>

template<int id> 
struct IdToType
{
    typedef void type;
    static const int s_nTypeId = -1;
};


template<class T> 
struct TypeToId
{
    typedef T type;
    static const int s_nTypeId = -1;
};


template<> struct IdToType<1>    {typedef int   type; static const int s_nTypeId = 1;};
template<> struct TypeToId<int>  {typedef int   type; static const int s_nTypeId = 1;};
                                                
template<> struct IdToType<2>    {typedef char  type; static const int s_nTypeId = 2;};
template<> struct TypeToId<char> {typedef char  type; static const int s_nTypeId = 2;};
                                 
template<> struct IdToType<3>    {typedef short type; static const int s_nTypeId = 3;};
template<> struct TypeToId<short>{typedef short type; static const int s_nTypeId = 3;};

template<> struct IdToType<4>    {typedef float type; static const int s_nTypeId = 4;};
template<> struct TypeToId<float>{typedef float type; static const int s_nTypeId = 4;};


int main(int argc, char* argv[])
{
    std::cout << "id of int = "   << TypeToId<int>::s_nTypeId   << std::endl;
    std::cout << "id of float = " << TypeToId<float>::s_nTypeId << std::endl;

    float f = 97.234f;
    IdToType<1>::type n = static_cast<IdToType<1>::type>(f);

    std::cout << "n = " << n << std::endl;

    auto ch = static_cast<IdToType<TypeToId<char>::s_nTypeId>::type>(f);
    std::cout << "ch = " << ch << std::endl;

    return 0;
}

id of int = 1 id of float = 4 n = 97 ch = a

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

__>так на одной платформе будет одна система, на другой — другая (тот же uint64_t не всюду будет). и что? мне самому всеми этими техническими деталями заниматься? программисту просто должны предоcтавить средство работы —

Ну так и будет примерно

fundamental_type_to_id<uint64t>::id;
fundamental_id_to_type<15>::type;

только с uint64_t проблемка будет. Он не всегда есть, так что твой код с таким типом будет непереносимый. В библиотеке-то можно условную компиляцию намутить, а вот что в клиентском коде делать?

Ну и не ясно, должны ли в перечислении участвовать фундаментальные нестандартные типы, ну __m128 например?

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

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

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

BFE>>>Набросок давно лежит рядом
BFE>>>проверка здесь

__>>да, прием интересный, но все равно еще же и морока с реализацией
__>>

__>>cast_to_fundamental_type(fundamental_type_id, val)
__>>

__>>будет.

BFE>Вы уж определитесь с набором операций и требований, а то складывается впечатление, что вы сами не знаете, чего вам надо:

ладно, может, вы и правы.

п.с. все же речь шла про динамическое приведение типов (в процессе работы программы),а не статическое

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

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

__>>так на одной платформе будет одна система, на другой — другая (тот же uint64_t не всюду будет). и что? мне самому всеми этими техническими деталями заниматься? программисту просто должны предоcтавить средство работы —

E>Ну так и будет примерно

fundamental_type_to_id<uint64t>::id;
E>fundamental_id_to_type<15>::type;

речь шла про что-то наподобие cast_to_fundamental_type(id, buffer), где buffer — просто байтовый буффер. например, для организации

class Variant
{
  int m_type_id;
  char m_buff[8];

public:
  //------------------------
  Variant():m_type_id(-1){}
  //------------------------
  template<typename T>
  void setVal(T val)
  {
     m_type_id = get_fundamental_type_id<T>();
     *reinterpret_cast<T*>(m_Buffer) = val;
  }
  //------------------------
  template<typename T>
  bool is(void)const
  {
     return get_fundamental_type_id<T>() == m_type_id;
  }
  //------------------------
  template<typename T>
  T get_casted_val()
  {
     return cast_to_fundamental_type(m_type_id, m_buff);
  }
  //------------------------
}

но, прикинув, я понял, что смысла в таком особого нет..

	От:	B0FEE664
	Дата:	07.04.16 12:34
	Оценка:

	От:	_hum_
	Дата:	07.04.16 13:08
	Оценка:

	От:	B0FEE664
	Дата:	07.04.16 14:26
	Оценка:	+1

	От:	Erop
	Дата:	07.04.16 15:03
	Оценка:

	От:	_hum_
	Дата:	07.04.16 15:07
	Оценка: