Using Initializer Lists in Custom Containers

std::initializer_list is a powerful tool for initializing custom container types, providing a flexible and intuitive way to pass a list of values.

To use std::initializer_list in your custom containers, you need to define a constructor that accepts an initializer_list and use it to initialize your container's internal storage.

Here's an example of a simple custom container that uses std::initializer_list:

1#include <iostream>
2#include <vector>
3
4template <typename T>
5class CustomContainer {
6public:
7  CustomContainer(std::initializer_list<T> initList)
8    : data{initList} {}
9
10  void Log() const {
11    for (const auto& elem : data) {
12      std::cout << elem << ' ';
13    }
14  }
15
16private:
17  std::vector<T> data;
18};
19
20int main() {
21  CustomContainer<int> myContainer{
22    1, 2, 3, 4, 5
23  }; 
24  myContainer.Log();
25}

11 2 3 4 5

In this example, CustomContainer is a template class that accepts a type parameter T. The constructor takes an std::initializer_list<T> and uses it to initialize a std::vector<T> which serves as the internal storage.

When you create an instance of CustomContainer, you can use brace-enclosed lists to initialize it, just like with standard containers. This makes your custom container more intuitive to use.

You can also use std::initializer_list to forward values to another container or process them as needed. Here's another example where we initialize a container with a sum of all elements:

1#include <iostream>
2#include <numeric>
3#include <vector>
4
5class SumContainer {
6public:
7  SumContainer(std::initializer_list<int> initList)
8    : sum{std::accumulate(
9      initList.begin(), initList.end(), 0
10    )} {}
11
12  void Log() const {
13    std::cout << "Sum: " << sum;
14  }
15
16private:
17  int sum;
18};
19
20int main() {
21  SumContainer myContainer{1, 2, 3, 4, 5}; 
22  myContainer.Log();
23}

1Sum: 15

In this case, SumContainer takes an std::initializer_list<int> and calculates the sum of its elements. This value is stored in a private member and logged to the console.

Using std::initializer_list in custom containers enhances flexibility and makes initialization straightforward, improving the overall usability of your container types.