when variant and when virtual function

Daniel Parker

3 min read

·

16-03-2025

1

0

Share

Choosing between variant and virtual functions in C++ often hinges on the specific design problem. Both offer ways to handle different types of data or behavior, but they achieve this in fundamentally different ways. This article clarifies when each is the appropriate choice.

Understanding variant

The std::variant (introduced in C++17) is a type-safe union. It can hold one of several types at any given time. This is ideal for situations where a variable could represent multiple, distinct data types. The type held is known at runtime, meaning you must explicitly check which type is currently active before attempting to access its value.

When to use variant

• Representing data with multiple possible types: Imagine a system processing orders. An order might contain an integer quantity for a single item or a vector of integers for multiple items. A variant could elegantly handle both cases within a single variable.

• Type-safe unions: Unlike traditional unions, std::variant prevents accidental access to the wrong type. If you try to access a type that isn't currently stored, it'll result in a runtime exception (e.g., std::bad_variant_access). This improves code safety significantly.

• Handling different data representations: You might have data coming from multiple sources, each with its own format. A variant can combine these formats into a single, manageable data structure.

• Implementing tagged unions: variant is perfect for implementing tagged unions (also known as discriminated unions or algebraic data types), where the active type implicitly carries semantic meaning.

Example:

#include <variant>
#include <string>
#include <vector>

std::variant<int, std::string, std::vector<double>> data;

data = 10; // data now holds an integer
data = "Hello"; // data now holds a string
data = std::vector<double>{1.1, 2.2, 3.3}; // data now holds a vector

// Accessing the data requires a check:
if (std::holds_alternative<int>(data)) {
  int value = std::get<int>(data);
  // ... process integer ...
} else if (std::holds_alternative<std::string>(data)) {
  std::string value = std::get<std::string>(data);
  // ... process string ...
} //... and so on

Understanding Virtual Functions

Virtual functions are a cornerstone of polymorphism in C++. They allow you to call methods on objects of different classes through a base class pointer or reference. The actual method called depends on the runtime type of the object, not its declared type. This enables flexible and extensible designs.

When to use Virtual Functions

• Implementing polymorphism: When different classes need to provide different implementations of the same interface. A classic example is a shape hierarchy (circle, square, triangle) where each shape has a draw() method.

• Extensible designs: Adding new classes that conform to the base class interface is straightforward without modifying existing code (the base class). This is a key strength of polymorphism and virtual functions.

• Dynamic behavior: The specific behavior is determined at runtime.

Example:

#include <iostream>

class Shape {
public:
  virtual void draw() { std::cout << "Drawing a generic shape\n"; }
  virtual ~Shape() = default; // Important for polymorphic deletion
};

class Circle : public Shape {
public:
  void draw() override { std::cout << "Drawing a circle\n"; }
};

class Square : public Shape {
public:
  void draw() override { std::cout << "Drawing a square\n"; }
};

int main() {
  Shape* shape1 = new Circle();
  Shape* shape2 = new Square();

  shape1->draw(); // Calls Circle::draw()
  shape2->draw(); // Calls Square::draw()

  delete shape1;
  delete shape2;
  return 0;
}

variant vs. Virtual Functions: Key Differences

Choosing the Right Tool

The choice between std::variant and virtual functions depends entirely on your goals. If you need to represent data that can have different types, std::variant is your solution. If you need to provide different implementations of a common interface, virtual functions are the appropriate choice. In some sophisticated designs, you might even use both together!