выполнения Определение типа

Question

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

void changeMode(int mode) 
{ 
    if(mode == 1) 
    { 
      typedef MyType float; 
    } 
    else if(mode == 2) 
    { 
      typedef MyType double; 
    } 
} 

int main(int argc, char *argv[]) 
{ 
    MyType (2); 
    MyType A = 3; 
    MyType B = 2; 
    MyType C = A + B; 

    return 0; 
} 

это возможно? Это классический пример шаблонов? можно избежать использования шаблонов? Моя цель - централизовать определение типа, чтобы можно было переключаться во время выполнения, без необходимости расширять его для каждого класса или использовать «шаблоны» для каждого класса/функции, которые будут использовать данный тип.

Answer 1

Вы можете извлечь свой тип-зависимый код для функционирования шаблона (или шаблон класса в более сложных случаях):

template <typename MyType> 
void ExecuteTypeDependentCode() 
{ 
    MyType A = 3; 
    MyType B = 2; 
    MyType C = A + B; 
} 

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

enum Modes 
{ 
    FloatMode = 1, 
    DoubleMode = 2 
}; 

void ExecuteTypeDependentCode(Modes mode) 
{ 
    switch (mode) 
    { 
     case FloatMode: 
      ExecuteTypeDependentCode<float>(); 
      break; 

     case DoubleMode: 
      ExecuteTypeDependentCode<double>(); 
      break; 
    } 
} 

Пример использования:

int main(int argc, char *argv[]) 
{ 
    ExecuteTypeDependentCode(DoubleMode); 

    return 0; 
} 

Процесс переключения может быть записан только один раз (я описал этот метод here).

Answer 2

typedef оценивается во время компиляции, поэтому нет.

но вы можете сделать что-то вроде этого, используя prepocessor:

#ifdef TYPE_FLOAT 
    typedef float Type; 
#else 
    typedef int Type; 
#endif 

, но имейте в виду, что это во время компиляции

Answer 3

Typedef оценивается статически, так что вам нужно сделать что-то вроде иметь «классический случай шаблонов»(независимо от того, что есть :))

template <int Mode> 
struct Dispatch { }; 

template <> 
struct Dispatch <0> { 
    using U = int; // fancy way of saying typedef 
}; 

template <> 
struct Dispatch <1> { 
    using U = char; // feel free to use typedef 
}; 

int main() { 
    Dispatch<0>::U x; // compile time constant in <> (zero) 
    x = 5; 
    Dispatch<1>::U y; // compile time constant in <> (one) 
    y = 'c'; 
} 

Answer 4

Как другие ответы указали, что это невозможно достичь с помощью typedef. Тем не менее, вы можете эмулировать это поведение с помощью polymorpic классов-оболочек:

#include <cstdio> 


class Gen 
{ 
public: 
    static int mode; 

    static Gen* get() 
    { 
     switch(mode) 
     { 
     case 1: 
      return new GenFloat(); 
     case 2: 
      return new GenDouble(); 
     } 

     return NULL; 
    } 
}; 

int Gen::mode = 0; 

class DoubleGen : public Gen 
{ 
public: 
    DoubleGen() : d(0) {} 
    DoubleGen(double val) : d(val) {} 

    double d; 
}; 

class FloatGen : public Gen 
{ 
public: 
    FloatGen() : f(0) {} 
    FloatGen(float val) : f(val) {} 

    float f; 
}; 




int main(void) 
{ 
    Gen::mode = 1; 

    Gen* _float = gen::get(); 

    gen::mode = 2; 

    Gen* _double = gen::get(); 

    delete _float; 
    delete _double; 

    return 0; 
}