std::variant causing handling when accessing value of a different type in C++17
I'm relatively new to this, so bear with me... I'm working on a personal project and I'm working with an scenario with `std::variant` in C++17 where accessing a value of a different type than what I initially set throws a runtime exception... Here’s a simplified version of my code: ```cpp #include <iostream> #include <variant> #include <string> int main() { std::variant<int, std::string> myVariant; myVariant = 42; // Assigning an int try { // Attempting to access as std::string std::cout << std::get<std::string>(myVariant) << std::endl; } catch (const std::bad_variant_access& e) { std::cerr << "behavior: " << e.what() << std::endl; } return 0; } ``` When I run this code, I see the following output: ``` behavior: bad variant access ``` I expected that the program would just return a default value or something similar instead of throwing an exception. I've checked the documentation and it states that `std::get` will throw `std::bad_variant_access` if the type doesn't match, but I was wondering if there’s a better way to handle this without resorting to exceptions. Is there a pattern or an alternative method to safely access the contained value without risking an exception? My goal is to avoid runtime crashes in cases where the variant type might not match. Any advice would be appreciated! What's the best practice here? This is part of a larger CLI tool I'm building.