Javatpoint Logo
Javatpoint Logo

Std::nullopt in C++

In this article, you will learn about the std::nullopt function in C++ with their example. It was originally included in the C++17 standard. std::nullopt is a constant in C++ that is mostly used in conjunction with std::optional to indicate the lack of a value. Here are some theories regarding std:nullopt:

  1. Optional values: The std::optional class template represents optional values, which might or might not have a value. The std::optional is a more expressive and secure solution than pointers or sentinel values (such as -1 or nullptr) to represent missing values.
  2. The Need for std::nullopt: Before std::nullopt was introduced when working with optional types, developers had to rely on conventions or use a variety of sentinel values to indicate the lack of a value. A consistent and understandable approach to express this absence is through std::nullopt.
  3. Reprographic of Absence: An std::optional object is in a disengaged state when it is created without a value assigned to it. It indicates that it is empty, and std::nullopt can be used to explicitly express this situation.
  4. The introduction of std::nullopt: Before C++17, there was a tendency to express the lack of a value by utilizing conventions, special values (like -1), or null pointers, all of which could lead to errors. The std::nullopt was added to give a standardized and unambiguous manner of indicating that an optional value is empty.
  5. Use and Purpose: std::nullopt is used to indicate that a value is missing from a std::optional object, which is a nullable container for an optional value. It enables you to differentiate between an empty state and a valid value. It is very crucial when working with optional or nullable types while upholding type safety.
  6. Type Safety: Type safety is achieved by using std::nullopt in conjunction with std::optional. An optional that is empty can be distinguished from one that has a valid value, and the compiler aids in enforcing this distinction.
  7. Comparing and Testing: You can compare it to std::nullopt to determine whether a std::optional has a value. As an illustration, you can compare directly with optionalVar == std::nullopt or use has_value().
  8. Use Cases: std::nullopt is useful in several situations, including error handling, functions that might return an empty result, and optional configuration options. It is useful in giving a clear indication when there is no useful value to deal with.
  9. Clearer Code: Code that uses std::nullopt is more self-documenting and straightforward. It clarifies when a function might not deliver a valid result or when a variable might be empty.


Let's take an example to illustrate the use of std::nullopt in C++:


Division by zero is not possible.


  1. #include <iostream> and #include <optional>: These lines include the optional values and required libraries for input/output operations.
  2. Divide(int a, int b) in std::optional: This function attempts to divide two integer inputs, a and b, by dividing a by b. It returns std::nullopt, which indicates that the division is not possible if the divisor b is zero. It returns the division's outcome if b is non-zero.
  3. int main(): It is the main function where the program execution starts.
  4. Two integer variables, a and b, are initialized to 10 and 0, in the lines that follow int a = 10; and int b = 0;.
  5. auto result = divide(a, b);: The result is stored in the result variable after this line uses the division function with the arguments a and b. Returning std::nullopt indicates that the division is not possible, or that b is 0.
  6. if (result.has_value()): After that, the code checks if 'result' has a value using result.has_value(). If 'result' has a value, it prints the result using result.value(). If 'result' does not have a value (indicating division by zero), it prints an error message.
  7. The division result is "" \\ result.value() \\ std::endl;: This line writes the division's result to the console if it can divide.
  8. std::cout << "Division by zero is not possible." << std::endl;: If the division is not possible, this line prints an appropriate message to the console.
  9. return 0;: The operating system receives 0 in response to this line, which shows that the program has been successfully executed.

Youtube For Videos Join Our Youtube Channel: Join Now


Help Others, Please Share

facebook twitter pinterest

Learn Latest Tutorials


Trending Technologies

B.Tech / MCA