Using std::optional as a return type

Using std::optional as a return type is a good choice when a function might not always have a meaningful value to return. Some common scenarios include:

Functions that search for a value

If a function searches for a value in a data structure and the value might not be present, it can return an std::optional. The presence of a value in the returned optional indicates that the value was found.

1#include <optional>
2#include <vector>
3
4std::optional<int> find_value(
5  const std::vector<int>& vec, int value) {
6  for (int i : vec) {
7    if (i == value) {
8      return i;
9    }
10  }
11  return std::nullopt;
12}

Functions that parse input

If a function tries to parse a value from input and the input might be invalid, it can return an std::optional. The presence of a value in the returned optional indicates that the parsing was successful.

1#include <optional>
2#include <string>
3
4std::optional<int> parse_int(
5  const std::string& s) {
6  try {
7    return std::stoi(s);
8  } catch (...) {
9    return std::nullopt;
10  }
11}

Functions that compute a result

If a function computes a result and the computation might fail or not be possible for certain inputs, it can return an std::optional. The presence of a value in the returned optional indicates that the computation succeeded.

1#include <cmath>
2#include <optional>
3
4std::optional<double> sqrt_positive(double x) {
5  if (x >= 0) {
6    return sqrt(x);
7  } else {
8    return std::nullopt;
9  }
10}

In all these cases, using std::optional makes it clear to the caller that the function might not always return a value, and provides a clean way to handle that situation.