Блог

У меня есть следующий код

 template <typename T>
auto CallMe(int param) -> void {
    ...
}

auto Test(int userInput) -> void {
    int paramToUse = SomeFunction(userInput);
    if (userInput == 0) {
        CallMe<__int32>(paramToUse);
    } else if (userInput == 1) {
        CallMe<__int16>(paramToUse);
    } else if (userInput == 2) {
        CallMe<__int8>(paramToUse);
    } else if (userInput == 3) {
    ...
}
 

Мой вопрос в том, что, поскольку все вызовы в CallMe() точности одинаковы, кроме типа шаблона T , есть ли в C способ присвоить тип переменной в каждой условной ветви и передать ее CallMe() в одном месте, например

     typename T;

    if (userInput == 0) {
        T = __int32;
    } else if (userInput == 1) {
        T = __int16;
    } else if (userInput == 2) {
        T = __int8;
    } else if (userInput == 3) {
    ...

    CallMe<T>(paramToUse);
 

Таким образом, если подпись CallMe изменена, для обновления требуется только одна строка.

Как насчет:

 decltype(CallMe<__int32>)* callable; // function pointer 

// set the function address as necessary 
if (userInput == 0) {
  callable = CallMe<__int32>;
} else if (userInput == 1) {
  callable = CallMe<__int16>;
} else if (userInput == 2) {
  callable = CallMe<__int8>;
} else {
 // ...
} 

callable(paramToUse); // call it
 

Время выполнения — условные псевдонимы типов невозможны, поскольку C является статически типизированным языком; это означает, что все типы должны быть разрешены во время компиляции.

В зависимости от вашего сценария вы можете найти решение, используя std::variant , однако вам придется либо передать новую переменную в вашу CallMe функцию, либо заменить тип paramToUse на variant .

Редактировать:

 using VariantType = std::variant<std::monostate, std::uint8_t, std::uint16_t, std::uint32_t>;
void CallMe(const VariantType value) {
    if (const auto uint8Value = std::get_if<std::uint8_t>(amp;value))
        // use uint8Value in a meaningful way
    else if (const auto uint16Value = std::get_if<std::uint16_t>(amp;value))
        // ...
    
    // ...
}

void function(const int userInput) {
    const auto result = SomeFunction(userInput);
    
    VariantType value {};
    if (result == 0)
        value = static_cast<std::uint32_t>(123);
    else if (result == 1)
        value = static_cast<std::uint16_t>(1234);
    // more conditions
    CallMe(value);
}
 

поскольку все вызовы в CallMe() точности одинаковы, за исключением типа шаблона T , есть ли в C способ присвоить тип переменной в каждой условной ветви и передать ее CallMe() в одном месте

Насколько я знаю, нет.

Ну … есть using

 if (userInput == 0) {
    using T = __int32;
} else if (userInput == 1) {
    using T = __int16;
} ...

CallMe<T>(paramToUse); // T is out of scope
 

но область действия using не распространяется на вызов функции.

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

Отличается, если вы можете передать userInput как известное значение во время компиляции: в этом случае вы можете создать своего рода массив типов (используя std::tuple , например) и выбрать тип в вызове.

Например, предположим userInput , что значение параметра шаблона (так известно во время компиляции) и userInput значение упорядочены, начиная с нуля (как в вашем вопросе), вы можете написать

 template <std::size_t userInput>
void Test ()
 {
   using typeArray = std::tuple<__int32, __int16, __int8>;

   CallMe<std::tuple_element_t<userInput, typeArray>>(paramToUse);
 }