How to implement a runtime type switching class in C++

Question

How to implement a class that dynamically switching types using std::variant in runtime?

I'm currently trying to create a class that can:

Store a value in a std::variant with configurable type options (in my case double and float)
Dynamically switch the active type at runtime using a setType<T>() method
Be callable as a function to convert inputs to the currently active type

Here's my current attempt of implementation:

#include <variant>
#include <iostream>
#include <typeinfo>

class TypeAliasClass {
public:
    TypeAliasClass() {
        value = float(1);
    }
    template <typename T>
    auto operator()(T transformable) {
        return std::visit([&](const auto& active_value) {
            using ActiveType = std::decay_t<decltype(active_value)>;
            
            if (std::is_convertible_v<T, ActiveType>) {
                return static_cast<ActiveType>(transformable);
            } else {
                std::cerr << "Couldn't convert given parameter to active type(" 
                          << typeid(ActiveType).name() << ")\n";
                return ActiveType{};
            }
        }, value);
    }
    
    template<typename T>
    void setType() {
        value = T(1);
    }
    
    ~TypeAliasClass() {
        std::cout << "Destroying TypeAliasClass with active type: " 
                  << std::visit([](auto&& arg) { 
                         return typeid(arg).name(); 
                     }, value) 
                  << std::endl;
    }

private:
    std::variant<float, double, int> value; // int was included as an exmaple
};

Example Usage:

TypeAliasClass converter;

converter.setType<int>();
std::cout << converter(3.14) << "\n";  // Returns 3
converter.setType<double>();
std::cout << converter("69") << "\n";  // Error

std::variant<std::type_identity<Ts>...> seems more appropriate, as you don't store value. — Jarod42
– Jarod42, Commented Apr 22 at 12:27
return type of auto operator() cannot depend of runtime value (type stored in the variant). — Jarod42
– Jarod42, Commented Apr 22 at 12:28
The static type of a non-templated expression is fixed. You can't have converter(3.14) return two different types on different invocations. This is fundamental to C++. — Weijun Zhou
– Weijun Zhou, Commented Apr 22 at 12:34

Jarod42 · Accepted Answer · 2025-04-22 16:43:21Z

std::variant<std::type_identity<Ts>...> seems more appropriate, as you don't store value.

Return type of template <typename T> auto operator()(T transformable) is problematic, as it should not depend of runtime value (content of the variant).

Instead you could have a apply/visit function, something like:

template <typename... Ts>
class TypeAliasClass {
public:
    TypeAliasClass() = default;

    template<typename T>
    void setType() { typeVar = std::type_identity<T>(); }

    template <typename F, typename T>
    decltype(auto) apply(F&& f, T transformable) {
        return std::visit([&]<typename ActiveType>(std::type_identity<ActiveType>) {
            if constexpr (std::is_convertible_v<T, ActiveType>) {
                return f(static_cast<ActiveType>(transformable));
            } else {
                std::cout << "Couldn't convert given parameter to active type(" 
                          << typeid(ActiveType).name() << ")\n";
                throw std::runtime_error("Incompatible type");
            }
        }, typeVar);
    }
    
private:
    std::variant<std::type_identity<Ts>...> typeVar;
};

int main()
{
  TypeAliasClass<float, double, int> converter; // type is the first one: float

  converter.setType<int>();
  converter.apply([](auto v){ std::cout << v << "\n"; }, 3.14);  // print 3
}

Demo

NeKon · Accepted Answer · 2025-04-22 18:43:21Z

0

I wanted a single function to return either float or double based on a runtime condition (e.g. a precision flag). After trying various approaches, including suggestions from comments and other answer, I realized there’s no magic pill for this in C++

The closest I got was using decltype with a ternary operator:

decltype(use_double_precision ? 1.0 : 1.0f)

However, this still resolves at compile time.

C++’s type system demands precise, compile-time-known types. I learned that lesson, and won't do the same mistake again.

answered Apr 22 at 18:43

NeKon

3141 silver badge13 bronze badges

4 Comments

Jarod42 Apr 23 at 7:33

decltype(use_double_precision ? 1.0 : 1.0f) is double unconditionally.

Jarod42 Apr 23 at 7:34

std::conditional<compile_time_cond, double, float> might interest you.

NeKon Apr 23 at 7:38

Yes, I know. As I mentioned earlier, that’s the closest I could get, but the compiler still generates code with double as the type there.

NeKon Apr 23 at 7:41

@Jarod42 That still requires a condition to be defined at compile time

Collectives™ on Stack Overflow

How to implement a runtime type switching class in C++

2 Answers 2

Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related