Int 2 type во время выполнения

@Eraston · Регистрация: 09.09.2014

Студворк — интернет-сервис помощи студентам

Здравствуйте.

Имеется необходимость, (наверное), реализовать трансляцию инта в тип во время выполнения:

С++

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
#include <iostream>
 
// ** Object type
enum class e_type:
    unsigned
{
    ONE,
    TWO,
    SIZE
};
 
// ** Check raw-type
e_type cvtType( std::underlying_type<e_type>::type n ){
    if( n >= static_cast<std::underlying_type<e_type>::type>( e_type::SIZE ) )
        throw e_type{ e_type::SIZE };
    return static_cast<e_type>( n );
}
 
// ** Class of objects 1
struct one{
    void operator()(){ std::cout << "One!" << "\n";; }
};
 
// ** Class of objects 2
struct two{
    void operator()(){ std::cout << "Two!" << "\n";; }
};
 
// ??
using t_template_function = int ( * )( void*, ... );
 
// ** Executioner of function with determined type
template<class T,class F,class ...Args>
int exec( F f, Args&&...args ){
    {
        CLASS_T_IS_UNCHECKED_FOR_USING:;
    }
    f<T>( args );
    return 0;
}
 
#if 1
// !! Must be array of determined functions
constexpr t_template_function f[2] = {
    exec<one>,
    exec<two>
};
#endif
 
// ** Some class
class something{
    char example_data;
private:
    template<class T>
    int anew( int k ){
    //  std::cout << k << "\n";
        T a{};
        a();
        return 0;
    }
    template<class T>
    int rem(){
        T a{};
        return 0;
    }
public:
    void create( e_type k ){
        auto result = f[size_t(k)]( anew, 25 );
        //decltype( f[0] ) p{};
    }
    void remove( e_type k ){
        example_data = rand();
        auto result = f[size_t( k )]( rem );
    }
};
 
int main(){
    something a{};
    int input_data;
    std::cin >> input_data;
    try{
        a.create( cvtType( input_data ) ); // Expected cout: 'One!' for 0, 'Two!' for 1 or ...
    }
    catch( e_type ){
        std::cout << "Error type";
    }
}

Можно ли это как-то сделать?
Да, есть специализации шаблонных функций, но писать каждый раз switch-case: a.function_name<type>() или массивы указателей на функции для каждой функции - не очень. Тем более, речь идёт о случае выполнения тривиальных действий: вызов operator() в независимости от класса объекта; к тому же виртуализация классов не используется.

@DrOffset · 26.10.2022, 19:18

Eraston, честно говоря не очень понятно чего вы хотите. Ну то есть ясно, что вы хотите как-то диспатчить некое runtime-значение в вызов функции, но каким образом этот вызов будет с этим значением связан совершенно не ясно.
И вот это особенно не понятно: "в независимости от класса объекта". Это как?

Добавлено через 3 минуты
В любом случае "int 2 type во время исполнения" возможен только по заранее составленной структуре данных. Единственное что вы сможете сделать - это как-то автоматизировать составление этой структуры во время компиляции.

@Eraston · 26.10.2022, 20:18 **[ТС]**

Объяснения самому себе

Не по теме:

...

Не по теме:

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

И вот это особенно не понятно: "в независимости от класса объекта". Это как?

Примерно так, что где-то в коде есть строки наподобие:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void function( e_type t ){
// ...
// When t is e_type::CAR
auto p = car.operator()();
// ...
// When t is e_type::LIST
auto p = list.operator()();
// ...
// When t is e_type::FLOWER
auto p = flower.operator()();
// ...
// When t is e_type::TEXT
auto p = text.operator()();
// ...
}

Понятно, что чтобы зайти в нужный кусок кода, нужно это каким-то образом выбрать (через switch-case, например). Но таких функций несколько (с таким построением), да и e_type может содержать n-цать значений, поэтому и хотелось бы писать что-то вроде:

C++
1
2
3
4
5
6
7
template<class T>
void operate(){
return 
}
void function( e_type t ){
auto p = translator[t]( func );
}

И тут, короче, пришло осознание, что operator() - метод класса, и такие вещи, условно говоря, можно даже через define транслировать: #define MACRO(_t_) _t_.operator()
А вопрос темы возник на основе случая внешнего управления менеджер-классом, который может, например, создавать объекты разных типов...

Короче говоря, хочется написать:

C++
1
2
3
4
5
6
7
8
9
10
void manager::create( e_type t, void* data ){
    auto p = allocate[t];
    switch( t ){
        case e_type::CAR:
            {
                
            }
            break;
    }
}

Короче говоря, хочется сопоставление int и типа, чтобы писать как-то так:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
class manager{
    // ...
private:
    template<class T, class... Args>
    T* manager::usual_create( Args ...args ){
        // Create a new managed object ...
        return add( T::create( args ) );
    }
 
    template<e_type T, class ...Args, class R>
    R* manager::create( Args...args ){
        // Add object of
        return usual_create</* Translate 'T' to class */>( args );
    }
public:
    void manager::create( e_type t ){
        // ...
        case e_type::LIST:
            {
                auto p = create<t>( header );
                p->setData( /* ... */ );
            }
            break;
        // ...
        case e_type::FLOWER:
            {
                auto p = create<t>( header );
                p->colorizing( /* ... */ );
            }
            break;
        // ...
    }
    // ...
};

Алексей1153 · 26.10.2022, 20:22

Eraston, мне кажется, происходит изобретение std::variant

@Eraston · 26.10.2022, 20:32 **[ТС]**

Сообщение от Алексей1153

Eraston, мне кажется, происходит изобретение std::variant

Да как-то совсем нет (если понимаю). Скорее, попытка сделать типизацию на основе целочисленного значения

@DrOffset · 26.10.2022, 21:27

Eraston, Ну сделайте список типов и деспетчеризируйте его в рантайме (через рекурсивное инстанцирование).
Что-то типа того:

C++
1
2
3
4
5
6
7
8
9
template <typename F, typename S, typename ...E>
void match(int val, F m, type_set<S, E...>) {
    if(val == S::value) {
        m(std::type_identity<typename S::type>{});    
    }
    else if constexpr(sizeof...(E) > 0) {
        match(val, m, type_set<E...>{});
    }
}

@Eraston · 26.10.2022, 23:23 **[ТС]**

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

Кликните здесь для просмотра всего текста

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
#include <iostream>
 
// ** Object type
enum class e_type:
    unsigned
{
    ONE,
    TWO,
    SIZE
};
 
// ** Check raw-type
e_type cvtType( std::underlying_type<e_type>::type n ){
    if( n >= static_cast<std::underlying_type<e_type>::type>( e_type::SIZE ) )
        throw e_type{ e_type::SIZE };
    return static_cast<e_type>( n );
}
 
// ** Class of objects 1
struct one{
    void operator()(){ std::cout << "One!" << "\n"; }
};
 
// ** Class of objects 2
struct two{
    void operator()(int s,int k){ std::cout << "Two! and " << s << k << "\n"; }
};
 
 
template<e_type T>
struct t_match{
    using type = void;
};
 
#if 1
template<>
struct t_match<e_type::ONE>{
    using type = one;
};
 
template<>
struct t_match < e_type::TWO>{
    using type = two;
};
#endif
// ** Some class
class something{
    char example_data;
private:
    #if 0
    template<class T>
    int anew( int k ){
        std::cout << k << "\n";
        T a{};
        a();
        return 0;
    }
    #endif
    template<e_type T,class ...Args>
    int anew( Args&&...args ){
        using type = t_match<T>::type;
        type a{};
        a( args... );
        return 0;
        //return anew<>(k);
    }
public:
    void create( e_type k ){
        #if 1
        switch( k ){
            case e_type::ONE:
                {
                    auto result = anew<e_type::ONE>(  );
                }
            break;
            case e_type::TWO:
                {
                    auto result = anew<e_type::TWO>( 2,5 );
                }
                break;
        }
        #else
        //std::function<const t_f> = *f[size_t( k )];
        #endif
    }
};
 
int main(){
    something a{};
    int input_data;
    std::cin >> input_data;
    try{
        a.create( cvtType( input_data ) ); // Expected cout: 'One!' for 0, 'Two!' for 1 or ...
    }
    catch( e_type ){
        std::cout << "Error type";
    }
}

@Eraston · 05.11.2022, 06:40 **[ТС]**

Может, из этого что-то получится:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
enum e_type2{
    ONE, TWO, SIZE
};
 
struct s_a{
    int k = 10;
    void out(){ std::cout << "s_a\n"; }
};
 
struct s_b{
    double c = 13.;
    void out(){ std::cout << "s_b\n"; }
};
 
// ** Manager interface
class Base_{
public:
    virtual void out_type() = 0;
    virtual void out() = 0;
};
 
// ** Typilization of interface
template<class T>
class I_:
    public Base_
{
protected:
    using type = T;
public:
    virtual void out_type()override{
        T().out();
    }
    virtual void out()override{
        T().out();
    }
};
 
// ** Realization of interface
class IA:
    public I_<s_a>
{ 
public:
    virtual void out()override{
        std::cout << s_a().k << "\n";
    }
};
 
// ** Realization of interface
class IB:
    public I_<s_b>
{
    I_::type arr[10];
public:
    virtual void out()override{
        std::cout << s_b().c << "\n";
    }
};
 
Base_* interfaces[e_type2::SIZE] = {
    new IA,
    new IB
};
 
void main(){
    int t;
    std::cin >> t;
    interfaces[t]->out();
    interfaces[t]->out_type();
    for( int i = 0; i < e_type2::SIZE; ++i ){
        delete interfaces[i];
    }
}

Новые блоги и статьи Все статьи Все блоги /
1С: Контроль уникальности заводского номера Maks 23.03.2026 Алгоритм контроля уникальности заводского (или серийного) номера на примере документа выдачи шин для спецтехники с табличной частью. Данные берутся из регистра сведений, по которому настроено. . .	Хочу заставить корпорации вкладываться в здоровье сотрудников: делаю мат модель здравосохранения anaschu 22.03.2026 e7EYtONaj8Y Z4Tv2zpXVVo https:/ / github. com/ shumilovas/ med2. git	1С: Программный отбор элементов справочника по группе Maks 22.03.2026 Установка программного отбора элементов справочника "Номенклатура" из модуля формы документа. В качестве фильтра для отбора справочника служит группа номенклатуры. Отбор по наименованию группы. . .	Как я обхитрил таблицу Word Alexander-7 21.03.2026 Когда мигает курсор у внешнего края таблицы, и нам надо перейти на новую строку, а при нажатии Enter создается новый ряд таблицы с ячейками, то мы вместо нервных нажатий Энтеров мы пишем любые буквы. . .
Krabik - рыболовный бот для WoW 3.3.5a AmbA 21.03.2026 без регистрации и смс. Это не торговля, приложение не содержит рекламы. Выполняет свою непосредственную задачу - автоматизацию рыбалки в WoW - и ничего более. Однако если админы будут против -. . .	1С: Программный отбор элементов справочника по значению перечисления Maks 21.03.2026 Установка программного отбора элементов справочника "Сотрудники" из модуля формы документа. В качестве фильтра для отбора служит значение перечислений. / / Событие "НачалоВыбора" реквизита на форме. . .	Переходник USB-CAN-GPIO Eddy_Em 20.03.2026 Достаточно давно на работе возникла необходимость в переходнике CAN-USB с гальваноразвязкой, оный и был разработан. Однако, все меня терзала совесть, что аж 48-ногий МК используется так тупо: просто. . .	Оттенки серого Argus19 18.03.2026 Оттенки серого Нашёл в интернете 3 прекрасных модуля: Модуль класса открытия диалога открытия/ сохранения файла на Win32 API; Модуль класса быстрого перекодирования цветного изображения в оттенки. . .

@DrOffset 19500 / 10105 / 2461 Регистрация: 30.01.2014 Сообщений: 17,818
	26.10.2022, 19:18
	Eraston, честно говоря не очень понятно чего вы хотите. Ну то есть ясно, что вы хотите как-то диспатчить некое runtime-значение в вызов функции, но каким образом этот вызов будет с этим значением связан совершенно не ясно. И вот это особенно не понятно: "в независимости от класса объекта". Это как? Добавлено через 3 минуты В любом случае "int 2 type во время исполнения" возможен только по заранее составленной структуре данных. Единственное что вы сможете сделать - это как-то автоматизировать составление этой структуры во время компиляции. 0

Алексей1153 фрилансер 6465 / 5679 / 1131 Регистрация: 11.10.2019 Сообщений: 15,119
	26.10.2022, 20:22
	Eraston, мне кажется, происходит изобретение std::variant 0

Int 2 type во время выполнения

Решение