std::optional

Some Common Member Types and Functions of std::optional

std::option has a large number of member functions and types that are available to use with it. We will discuss some of these member types and methods in this section.

value_type

The value_type is a member type of the std::optional class. Itindicates the type of the value that the std::optional can hold.

reference

The reference variable is also a member type of the std::optional class. The "reference" represents a reference pointer to the stored value.

const_reference

Similar to the "reference" pointer it also a member type of the std::optional class. It represents a const reference pointer to the stored value.

has_value()

The has_value() method checks if the std::optional is holding a value.

operator* ()

The operator()* returns a reference to the value in the container.

operator->()

The opeartor->() method allows direct access to the member functions and properties of the value in the container.

value()

It returns the value present in the std::optional container. It throws an exception if the container is empty.

value_or()

The value_or() method works similar to the value() method but it returns a default value if the container is empty.

reset()

The reset() function resets the value present in the std::optional to a state of no value.

swap()

The swap() method is used to swap the values present in two different std::optional instances.

These are just some of the few methods and types present in the std::optional() function.

Example of std::optional in C++

In this section, we will look at the usage of std::optional in C++ with the help of some code examples. We will write a simple program just to check if the value present in our std::optional program is null or not.

First, let us look at a program to achieve the desired result without using std::optional.

Without Using std::optional

Code

• C++

C++

#include <iostream>
using namespace std;

// helper function
int helper (bool flag) {
	if (flag) {
		return 1;
	}
	else {
		return -1;
	}
}

int main () {
	int val = helper(true);
	if(val != -1){
               cout<<val<<endl;
        }
        return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Output

Now, we will try to get the same functionality as the above code but with the help of std::optional.

Code

• C++

C++

#include <iostream>
#include <optional>
using namespace std;

// std::optional class
optional <int> helper (bool flag) {
	if (flag) {
		return 1;
	}
	else{
		return nullopt;
	}
}

int main () {
        optional <int> val = helper(true);
	if(val){
                  cout<<*val<<endl;
        }
        return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Output

We achieved the same functionality in both the codes but std::optional made it easier for use to find if our specified condition was true or not. We don't have to deal with null types like -1, 0, nullptr when we use the std::optional class.

Disadvantages of std::optional in C++

While std::optional helps in reducing ambiguity and increasing the code readability of the program, it also has some drawbacks attached to it.
 

• Compatibility - std::optional is only available in the 2017 and later versions of C++. Hence, it can not be used in projects using earlier versions of C++.
   
• Less Usage - Even though std::optional is a very good method to check null values, it is still very less popular and unrecognizable amongst the users of C++.
   
• Compiler Support - Since it is a fairly new feature introduced in C++ 2017, std::optional may not be supported by all the compilers leading to ambiguous behavior.
   
• Performance - std::optional takes more memory as compared to simple boolean flag which can be used for the same purpose.

Frequently Asked Questions

What would happen if I tried to access the value of an empty std::optional?

We can use the value() method to access the value of a std::optional. If we try to access the value of an empty std::optional, the value() method will result in an exception.

How is std::optional different from std::variant?

In C++, std::optional is used to represent the presence or absence of a single value (like a boolean variable). On the other hand, std::variant is used to represent one value from a set of multiple values.

What are the major differences between std::optional and boost::optional?

Both std::optional and boost:optional are used to represent optional values. The main difference between them lies in their standardization. While std::optional is part of the Standard C++ library, boost::optional is a component of the Boost C++ library.

Conclusion

In this article, we discussed std::optional. We discussed in detail some member types of std::optional along with some examples of std::optional with suitable code implementations. In the end, we concluded by discussing some drawbacks of using std::optional and some frequently asked questions.

So now that you know about std::optional in C++, you can refer to similar articles.

• STL in C++
   
• Internal Implementation of std::sort()
   
• C++ String Find
   

You may refer to our Guided Path on Code Studios for enhancing your skill set on DSA, Competitive Programming, System Design, etc. Check out essential interview questions, practice our available mock tests, look at the interview bundle for interview preparations, and so much more!

Happy Learning!