optional

---

1. Default Initialization

std::optional<int> opt; // Initialized to empty (no value)

2. Value Initialization

std::optional<int> opt1 = 10; // Initialized with value 10

3. Copy Initialization

std::optional<int> opt2(opt1); // Copy the value from opt1

4. Move Initialization

std::optional<int> opt3(std::move(opt2)); // Move the value from opt2

5. Assignment

opt = 20; // Assigns the value 20 to opt

6. Copying Value

int val = *opt; // Dereferences to get the value

7. Checking for Value

if (opt) { // Checks if opt has a value
  // Execute code if opt has a value
}

8. Checking for Empty

if (!opt) { // Checks if opt is empty
  // Execute code if opt is empty
}

9. Using std::visit with std::optional

std::visit([](auto&& val) { std::cout << val; }, opt); // Print the value using polymorphic visitor

10. Using Lambda with std::optional

opt.value_or(0); // Returns the value if present, otherwise returns 0

11. Using Function Pointers with std::optional

auto func = [](auto&& val) { std::cout << val; };
std::visit(func, opt); // Print the value using function pointer

12. Using Algorithm with std::optional

std::for_each(std::begin(opt), std::end(opt), [](auto&& val) { std::cout << val; }); // Iterate over the value

13. Using std::copy with std::optional

std::copy(std::begin(opt), std::end(opt), std::back_inserter(vec)); // Copy the value to a vector

14. Using std::transform with std::optional

std::transform(std::begin(opt), std::end(opt), std::back_inserter(vec), [](auto&& val) { return std::to_string(val); }); // Transform the value to a string vector

15. Using std::find with std::optional

auto it = std::find(std::begin(opt), std::end(opt), 10); // Find the first instance of 10 in opt

16. Using std::count with std::optional

std::count(std::begin(opt), std::end(opt), 10); // Count the number of instances of 10 in opt

17. Using std::accumulate with std::optional

std::accumulate(std::begin(opt), std::end(opt), 0); // Sum the values in opt

18. Using std::minmax with std::optional

std::pair<int, int> result = std::minmax(opt1, opt2); // Find the minimum and maximum values from opt1 and opt2

19. Using std::max_element with std::optional

auto it = std::max_element(std::begin(opt), std::end(opt)); // Find the iterator to the maximum value in opt

20. Using std::min_element with std::optional

auto it = std::min_element(std::begin(opt), std::end(opt)); // Find the iterator to the minimum value in opt

21. Using std::sort with std::optional

std::sort(std::begin(opt), std::end(opt)); // Sort the values in opt

22. Using std::reverse with std::optional

std::reverse(std::begin(opt), std::end(opt)); // Reverse the values in opt

23. Using std::rotate with std::optional

std::rotate(std::begin(opt), std::begin(opt) + 1, std::end(opt)); // Rotate the values in opt by 1

24. Using std::partition with std::optional

auto it = std::partition(std::begin(opt), std::end(opt), [](auto&& val) { return val % 2 == 0; }); // Partition the values in opt based on even or odd

25. Using std::stable_partition with std::optional

auto it = std::stable_partition(std::begin(opt), std::end(opt), [](auto&& val) { return val % 2 == 0; }); // Partition the values in opt based on even or odd, preserving order

26. Using std::remove with std::optional

auto it = std::remove(std::begin(opt), std::end(opt), 10); // Remove all instances of 10 from opt

27. Using std::remove_if with std::optional

auto it = std::remove_if(std::begin(opt), std::end(opt), [](auto&& val) { return val % 2 == 0; }); // Remove all even values from opt

28. Using std::unique with std::optional

auto it = std::unique(std::begin(opt), std::end(opt)); // Remove duplicates from opt

29. Using std::merge with std::optional

std::optional<int> opt4 = 15;
std::optional<int> opt5 = 20;
std::merge(std::begin(opt1), std::end(opt1), std::begin(opt4), std::end(opt4), std::back_inserter(vec)); // Merge opt1 and opt4 into vec

30. Using std::set_union with std::optional

std::set_union(std::begin(opt1), std::end(opt1), std::begin(opt4), std::end(opt4), std::back_inserter(vec)); // Union of opt1 and opt4 into vec

31. Using std::set_intersection with std::optional

std::set_intersection(std::begin(opt1), std::end(opt1), std::begin(opt4), std::end(opt4), std::back_inserter(vec)); // Intersection of opt1 and opt4 into vec

32. Using std::set_difference with std::optional

std::set_difference(std::begin(opt1), std::end(opt1), std::begin(opt4), std::end(opt4), std::back_inserter(vec)); // Difference of opt1 and opt4 into vec

33. Using std::set_symmetric_difference with std::optional

std::set_symmetric_difference(std::begin(opt1), std::end(opt1), std::begin(opt4), std::end(opt4), std::back_inserter(vec)); // Symmetric difference of opt1 and opt4 into vec

34. Using std::map with std::optional

std::map<int, std::optional<int>> map;
map.insert(std::make_pair(1, 10)); // Insert a key-value pair into the map

35. Using std::unordered_map with std::optional

std::unordered_map<int, std::optional<int>> umap;
umap.insert(std::make_pair(1, 10)); // Insert a key-value pair into the unordered map

36. Using std::multimap with std::optional

std::multimap<int, std::optional<int>> mmap;
mmap.insert(std::make_pair(1, 10)); // Insert a key-value pair into the multimap

37. Using std::unordered_multimap with std::optional

std::unordered_multimap<int, std::optional<int>> ummap;
ummap.insert(std::make_pair(1, 10)); // Insert a key-value pair into the unordered multimap

38. Using std::set with std::optional

std::set<std::optional<int>> set;
set.insert(10); // Insert a value into the set

39. Using std::multiset with std::optional

std::multiset<std::optional<int>> mset;
mset.insert(10); // Insert a value into the multiset

40. Using std::unordered_set with std::optional

std::unordered_set<std::optional<int>> uset;
uset.insert(10); // Insert a value into the unordered set

41. Using std::unordered_multiset with std::optional

std::unordered_multiset<std::optional<int>> umset;
umset.insert(10); // Insert a value into the unordered multiset

42. Using std::tuple with std::optional

std::tuple<std::optional<int>, std::optional<char>> tup;
tup = std::make_tuple(10, 'a'); // Initialize a tuple with optional elements

43. Returning std::optional from a Function

std::optional<int> get_value() { return 10; } // Return an optional value from a function

44. Throwing Exception from std::optional

if (!opt) { throw std::invalid_argument("Optional is empty"); } // Throw an exception if opt is empty

45. Using std::make_optional with Constructor

std::optional<std::pair<int, int>> opt_pair = std::make_optional(std::pair<int, int>(1, 2)); // Initialize an optional value with a constructor

46. Using std::make_optional with Factories

std::optional<std::string> opt_str = std::make_optional<std::string>("hello"); // Initialize an optional value with a factory function

47. Using std::nullopt to Represent an Empty Value

std::optional<int> opt_empty = std::nullopt; // Initialize an empty optional value

48. Using std::optional_if to Initialize an Optional from a Condition

std::optional<int> opt_cond = std::optional_if(cond, value); // Initialize an optional value based on a condition

49. Using std::transform with std::optional to Convert Types

std::transform(std::begin(opt1), std::end(opt1), std::back_inserter(vec), [](auto&& val) { return std::string(val.value()); }); // Transform the optional values to strings

50. Using std::accumulate with std::optional to Aggregate Values

std::accumulate(std::begin(opt1), std::end(opt1), 0, [](auto&& sum, auto&& val) { return sum + val.value(); }); // Sum the optional values