When should I use std::variant instead of a union?

You should prefer std::variant over unions in most cases for a few key reasons:

1. Type safety: As discussed in the lesson, unions are not type-safe. You can easily access the wrong member of a union, leading to undefined behavior. std::variant provides type safety by ensuring you only access the currently active member.
2. No memory leaks: With unions, it's your responsibility to properly manage the lifetime of objects, which can be tricky and lead to memory leaks. std::variant handles the destruction of the contained object automatically.
3. Visitor pattern: std::variant supports the visitor pattern through std::visit, allowing you to easily perform operations on the contained value without explicit casting.
4. Cleaner code: Using std::variant results in cleaner, more readable code compared to unions. It abstracts away the low-level details and provides a user-friendly interface.

However, there are a few situations where you might still use a union:

1. Compatibility: If you're working with legacy codebases or interfaces that expect unions.
2. Performance: In some cases, unions may offer a slight performance advantage over std::variant due to lower overhead. However, this difference is usually negligible and not worth sacrificing type safety.

In general, std::variant is the better choice for most modern C++ codebases. It provides type safety, convenience, and expressive power that unions lack.