Heterogeneous Initializer Lists

std::initializer_list in C++ is designed to handle homogeneous data types, meaning all elements must be of the same type.

However, there are scenarios where you might want to work with heterogeneous data. Although std::initializer_list itself cannot handle heterogeneous types, there are alternative approaches to achieve similar functionality.

One common approach is to use std::tuple, which can store elements of different types:

1#include <iostream>
2#include <tuple>
3
4int main() {
5  std::tuple<int, double, std::string> myTuple{
6    1, 2.5, "Hello"}; 
7  std::cout << std::get<0>(myTuple) << ", "
8            << std::get<1>(myTuple) << ", "
9            << std::get<2>(myTuple);
10}

11, 2.5, Hello

In this example, std::tuple allows storing an int, double, and std::string together. You can access each element using std::get<>().

If you need a container that can dynamically handle different types, consider using std::variant or a base class with pointers to derived classes:

1#include <iostream>
2#include <variant>
3#include <vector>
4
5int main() {
6  std::vector<std::variant<
7    int, double, std::string>
8  > vec{1, 2.5, "Hello"}; 
9
10  for (const auto& elem : vec) {
11    std::visit([](auto&& arg) {
12      std::cout << arg << ", ";
13    }, elem);
14  }
15}

11, 2.5, Hello

std::variant can hold any one of the specified types at a time. Using std::visit, you can apply a visitor function to handle each type.

For more complex scenarios, you might use a base class with a polymorphic approach:

1#include <iostream>
2#include <vector>
3#include <memory>
4
5class Base {
6public:
7  virtual void Log() const = 0;
8  virtual ~Base() = default;
9};
10
11class DerivedInt : public Base {
12  int value;
13public:
14  DerivedInt(int val)
15    : value{val} {}
16  void Log() const override {
17    std::cout << value << ' ';
18  }
19};
20
21class DerivedDouble : public Base {
22  double value;
23public:
24  DerivedDouble(double val)
25    : value{val} {}
26  void Log() const override {
27    std::cout << value << ' ';
28  }
29};
30
31class DerivedString : public Base {
32  std::string value;
33public:
34  DerivedString(std::string val)
35    : value{val} {}
36  void Log() const override {
37    std::cout << value << ' ';
38  }
39};
40
41int main() {
42  std::vector<std::unique_ptr<Base>> vec;
43  vec.push_back(
44    std::make_unique<DerivedInt>(1)
45  );
46  vec.push_back(
47    std::make_unique<DerivedDouble>(2.5)
48  );
49  vec.push_back(
50    std::make_unique<DerivedString>("Hello")
51  );
52
53  for (const auto& elem : vec) {
54    elem->Log();
55  }
56}

11 2.5 Hello

This polymorphic approach allows you to store different types in a container, each derived from a common base class. This technique is flexible but requires more boilerplate code.

While std::initializer_list is limited to homogeneous types, using std::tuple, std::variant, or polymorphism provides powerful alternatives to handle heterogeneous data effectively.