std::variant in C++ 17

In the world of modern C++ programming, the std::variant is a powerful tool that allows you to work with multiple data types in a flexible and type-safe manner. In this article, we will discuss std::variant and explore its fundamentals, applications, and benefits with practical code examples.

Prerequisites: C++ data types, functions, unions, and classes.

What is std::variant?

A variant is a data type introduced in C++ 17 that can hold values of different types, much like a union in C. However, std::variant brings type safety to the table, making it a safer and more versatile alternative.

How Does std::Variant Work?

At its core, std::variant is a union of types. It can store one value at a time from a predefined set of types. Unlike a traditional union, std::variant keeps track of its active type, ensuring that you access the correct value.

Types Supported by std::Variant

std::variant can hold values of various data types, including fundamental types (int, double, etc.), user-defined types (custom classes or structs), and even other variants. This flexibility opens up a world of possibilities for handling complex data scenarios.

Syntax of std::variant

std::variant <Types...> var_name;

where,

• Types: All possible type of data that the variant may have to store.
• var_name: variant object name.

Methods Associated with std::variant

Some methods associated with std::variant to provide different facilities. Some of them are as follows:

S.No	Method	Description
1	index()	Returns the index of the type of data stored in the variant.
2	emplace()	In place construction of the value of the variant.
3	holds_alternative()	Check if the given type of data is stored inside the variant at the given moment in time.
4	get()	It retrieves the value of the given type or index from the variant.

Examples of std::variant

Let’s illustrate the std::variant with some code examples.

Example 1

C++

// C++ Program to illustrate std::variant
#include <iostream>
#include <string>
#include <variant>

using namespace std;

int main()
{
    variant<int, double, string> myVariant;

    myVariant = 42; // Assign an int
    // Access the int
    if (holds_alternative<int>(myVariant)) {
        cout << get<int>(myVariant) << endl;
    }

    myVariant = 3.14; // Assign a double
    // Access the double
    if (holds_alternative<double>(myVariant)) {
        cout << get<double>(myVariant) << endl;
    }

    myVariant = "Hello, Variant!"; // Assign a string
    // Access the string
    if (holds_alternative<string>(myVariant)) {
        cout << get<string>(myVariant) << endl;
    }

    return 0;
}

Output

42
3.14
Hello, Variant!

Example 2

C++

// C++ Program to illustrate std::variant
#include <iostream>
#include <variant>
using namespace std;

// Define custom data types
struct Circle {
    double radius;
};

struct Square {
    double side;
};

// driver code
int main()
{
    variant<Circle, Square> shapeVariant;

    // Create a Circle
    shapeVariant = Circle{ 5.0 };

    // Check the active type and perform operations
    // accordingly
    if (holds_alternative<Circle>(shapeVariant)) {
        Circle c = get<Circle>(shapeVariant);
        cout << "Circle with radius: " << c.radius << endl;
    }
    else if (holds_alternative<Square>(shapeVariant)) {
        Square s = get<Square>(shapeVariant);
        cout << "Square with side: " << s.side << endl;
    }
    else {
        // Handle the case where the variant does not
        // contain either a Circle or a Square
        cout << "Unrecognized shape" << endl;
    }

    return 0;
}

Output

Circle with radius: 5

Applications of std::Variant

Following are some main applications of the std::variant:

• Handling Multiple Data Types: One of the most common use cases for std::variant is when you need to work with functions or classes that can accept different data types. Instead of writing multiple overloads, you can use a variant to streamline your code and make it more maintainable.
• State Machines: State machines, a crucial concept in software engineering, often require managing different states and transitions. std::variant simplifies this by allowing you to represent states as types and transitions as functions, resulting in clean and efficient code.