std::visit is typically used in conjunction with the earlier mentioned Petty C++ - std::variant, and it is introduced in C++ 17 for handling data in std::variant and performing corresponding operations.
Basic Usage#
std::visit requires two main parameters:
-
visitor: a callable object (lambda function object) used to handle the data in the variant.
-
variants: one or more instances of
std::variant.
Example#
int main() {
// Create a std::variant that can store int or std::string
std::variant<int, std::string> var;
// Store an int value in the variant
var = 42;
// Use std::visit to handle the value in the variant
std::visit([](auto&& arg) {
std::cout << "Value: " << arg << std::endl;
}, var);
// Store a std::string value in the variant
var = std::string("Hello, world!");
// Use std::visit again to handle the new value
std::visit([](auto&& arg) {
std::cout << "Value: " << arg << std::endl;
}, var);
return 0;
}
Multiple Variants#
When handling multiple variants, the visitor needs to be able to process all possible types that may occur. If different type combinations are not handled in branches within the visitor, it will generate different function call logic for each possible type combination. If there are multiple variants, each containing multiple types, the possible type combinations grow exponentially.
To avoid this situation, the following methods can be used to save overhead:
- Reduce the number of types in the variant.
- Use
std::monostate// todo - Use branching.
- Use polymorphism.
template<typename T>
void process(const T& value) {
if constexpr (std::is_same_v<T, int>) {
std::cout << "Processing int: " << value << std::endl;
} else if constexpr (std::is_same_v<T, std::string>) {
std::cout << "Processing string: " << value << std::endl;
} else {
std::cout << "Processing other type" << std::endl;
}
}
By using if constexpr and template type deduction, the compiler will only generate specific logic for common types, while generic handling reduces unnecessary code generation.