std::optional
- contexts
While programming, we often come across scenarios where we may return/pass/use an object of a definite type. That is, the object may or may not have a value of a definite type. Therefore, we need a way to model pointer-like semantics: a pointer can be passed a nullptr to indicate the absence of a value. The solution is to define the object with an additional value of type bool as a flag indicating whether or not the object has a value. std::optional<> provides a type-safe way to implement such objects. - Memory size
Optional objects require memory equal to the size of the contained object plus the size of a bool type. As a result, optional objects are typically one byte larger than contained objects (plus possibly the space overhead of memory alignment). Optional objects do not require heap memory allocation and are aligned in the same way as contained objects.
#include <iostream>
#include <optional>
// Define a class without a default constructor
class MyClass {
public:
explicit MyClass(int value) : data(value) {}
~MyClass() {}
int getData() const {
return data;
}
private:
int data;
};
// exports std::optional Whether or not it contains a value
void check_optional_value(std::optional<MyClass>& opt) {
if (opt) {
std::cout << "Value present: " << opt->getData() << std::endl;
} else {
std::cout << "No value present." << std::endl;
}
}
int main() {
// Creates a value-less std::optional<MyClass>
std::optional<MyClass> opt1;
check_optional_value(opt1);
// Creates a valued std::optional<MyClass>
std::optional<MyClass> opt2{MyClass(42)};
check_optional_value(opt2);
// Try to pass the emplace added value
(24);
check_optional_value(opt1);
// Try to pass the operator= added value
opt1 = MyClass(56);
check_optional_value(opt1);
return 0;
}
Output:
Size of i: 4 bytes
Size of St8optionalIiE: 8 bytes
Size of 7MyClass: 4 bytes
Size of St8optionalI7MyClassE: 8 bytes
However, optional objects are not simply equivalent to embedded objects with the bool flag attached. For example, the constructor of an embedded object will not be called in the absence of a value (in this way, an embedded type without a default constructor can also be in a valid default state).
3. Semantics
Like std::variant<> and std::any, optional objects have value semantics. That is, the copy operation will be implemented as a deep copy: a new standalone object will be created, and the new object will have a copy of the original object's tokens and embedded values (if any) in its own memory space. The overhead of copying a std::optional<> with no intrinsic values is small, but the overhead of copying a std::optional<> with intrinsic values is approximately equal to the overhead of copying intrinsic values. Also, std::optional<> objects support move semantics.
4. Applications
(1) std::optional<> simulates an instance of any type that can be null. It can be used as a member, a parameter, a return value, and so on.
The following sample program demonstrates some of the functionality of using std::optional<> as a return value:
#include <optional>
#include <string>
#include <iostream>
// If possible.stringconvert toint：
std::optional<int> asInt(const std::string& s)
{
try {
return std::stoi(s);
}
catch (...) {
return std::nullopt;
}
}
int main()
{
for (auto s : {"42", " 077", "hello", "0x33"}) {
// try to putsconvert toint，and print the results：
std::optional<int> oi = asInt(s);
if (oi.has_value()) {
std::cout << "convert '" << s << "' to int: " << () << "\n";
}
else {
std::cout << "can't convert '" << s << "' to int\n";
}
}
}
(2) Another example of using std::optional<> is passing optional arguments and setting optional data members:
#include <optional>
#include <string>
#include <iostream>
class Name
{
private:
std::string first;
std::optional<std::string> middle;
std::string last;
public:
Name (std::string f, std::optional<std::string> m, std::string l)
: first{std::move(f)}, middle{std::move(m)}, last{std::move(l)} {
}
friend std::ostream& operator << (std::ostream& strm, const Name& n) {
strm << << ' ';
if () {
strm << * << ' ';
}
return strm << ;
}
};
int main()
{
Name n{"Jim", std::nullopt, "Knopf"};
std::cout << n << '\n';
Name m{"Donald", "Ervin", "Knuth"};
std::cout << m << '\n';
}
::Optional<> types and operations
(1) std::optional<> type standard library in header file
namespace std {
template
}
The following types and objects are also defined:
- A std::nullopt_t of type std::nullopt, which serves as the "value" of the optional object when it has no value.
- The std::bad_optional_access exception class, derived from std::exception, is thrown when accessing a value when there is no value.
Optional objects also use the
(2) std::optional<> operations
Table std::optional lists all the operations of std::optional<>:
#include <iostream>
#include <optional>
#include <variant>
#include <vector>
#include <set>
#include <map>
#include <string>
#include <cmath>
#include <functional>
#include <cassert>
#include <complex>
// Simplifying Code with Namespaces
using namespace std::string_literals;
// typical example 1：tectonic (geology) std::optional
void construct_optional() {
std::optional<int> o1; // does not contain a value
assert(!o1.has_value());
std::optional<int> o2(std::nullopt); // 显式表示does not contain a value
assert(!o2.has_value());
std::optional o3{42}; // derive std::optional<int>
assert(o3.has_value());
assert(*o3 == 42);
std::optional o4{"hello"}; // derive std::optional<const char*>
assert(o4.has_value());
assert(*o4 == "hello");
std::optional o5{"hello"s}; // derive std::optional<std::string>
assert(o5.has_value());
assert(*o5 == "hello");
// Initialize optional objects with multiple parameters
std::optional<std::complex<double>> o6{std::in_place, 3.0, 4.0};
assert(o6.has_value());
assert(o6->real() == 3.0 && o6->imag() == 4.0);
// utilization std::make_optional
auto o13 = std::make_optional(3.0); // std::optional<double>
assert(o13.has_value());
assert(*o13 == 3.0);
auto o14 = std::make_optional("hello"); // std::optional<const char*>
assert(o14.has_value());
assert(*o14 == "hello");
auto o15 = std::make_optional<std::complex<double>>(3.0, 4.0);
assert(o15.has_value());
assert(o15->real() == 3.0 && o15->imag() == 4.0);
}
// typical example 2：access value
void access_optional_value() {
std::optional<std::pair<int, std::string>> o{std::make_pair(42, "hello")};
assert(o.has_value());
assert(o->first == 42);
assert(o->second == "hello");
std::optional<std::string> o2{"hello"};
assert(o2.has_value());
assert(*o2 == "hello");
// Accessing when there is no value results in undefined behavior
o2 = std::nullopt;
assert(!o2.has_value());
// std::cout << *o2 << std::endl; // Undefined behavior
}
// typical example 3：utilization value_or
void use_value_or() {
std::optional<std::string> o{"hello"};
std::cout << o.value_or("NO VALUE") << std::endl; // exports "hello"
o = std::nullopt;
std::cout << o.value_or("NO VALUE") << std::endl; // exports "NO VALUE"
}
// typical example 4：comparisons
void compare_optionals() {
std::optional<int> o0;
std::optional<int> o1{42};
assert(o0 == std::nullopt);
assert(!(o0 == 42));
assert(o0 < 42);
assert(!(o0 > 42));
assert(o1 == 42);
assert(o0 < o1);
assert(!(o0 > o1));
std::optional<unsigned> uo;
assert(uo < 0);
assert(uo < -42);
std::optional<bool> bo;
assert(bo < false);
std::optional<int> o2{42};
std::optional<double> o3{42.0};
assert(o2 == 42);
assert(o3 == 42);
assert(o2 == o3);
}
// typical example 5：modified value
void modify_optional_value() {
std::optional<std::complex<double>> o; // not having a value
std::optional<int> ox{77}; // optional<int>，be valued at77
o = 42; // The value becomes complex(42.0, 0.0)
assert(o.has_value());
assert(o->real() == 42.0 && o->imag() == 0.0);
o = std::complex<double>{9.9, 4.4}; // The value becomes complex(9.9, 4.4)
assert(o.has_value());
assert(o->real() == 9.9 && o->imag() == 4.4);
o = ox; // OK，on account of int convert to complex<double>
assert(o.has_value());
assert(o->real() == 77.0 && o->imag() == 0.0);
o = std::nullopt; // o No more values
assert(!o.has_value());
(5.5, 7.7); // The value becomes complex(5.5, 7.7)
assert(o.has_value());
assert(o->real() == 5.5 && o->imag() == 7.7);
(); // o No more values
assert(!o.has_value());
o = std::complex<double>{88.0, 0.0}; // OK：The value becomes complex(88.0, 0.0)
assert(o.has_value());
assert(o->real() == 88.0 && o->imag() == 0.0);
o = std::complex<double>{1.2, 3.4}; // OK：The value becomes complex(1.2, 3.4)
assert(o.has_value());
assert(o->real() == 1.2 && o->imag() == 3.4);
}
// typical example 6：utilization lambda initialization set
void initialize_set_with_lambda() {
auto sc = [](int x, int y) {
return std::abs(x) < std::abs(y);
};
std::optional<std::set<int, decltype(sc)>> o8{std::in_place,
std::initializer_list<int>{4, 8, -7, -2, 0, 5},
sc};
assert(o8.has_value());
assert(o8->size() == 6);
}
int main() {
construct_optional();
access_optional_value();
use_value_or();
compare_optionals();
modify_optional_value();
initialize_set_with_lambda();
return 0;
}
6. Attention
(1) value() and value_or()
There is one difference between value() and value_or() that needs to be considered:4 value_or() returns a value, while value() returns a reference. This means the following call:
std::cout << middle.value_or("");
and:
std::cout << o.value_or("fallback");
both allocate memory implicitly, while value() never does.
However, when value_or() is called on a temporary object (rvalue), the value of the containing object will be moved away and returned as a value instead of calling the copy function construct. This is the only way to make value_or() work for types that are move-only, because the overloaded version of value_or() called on a left-value (lvalue) requires that the contained object be copyable.
Therefore, the most efficient implementation of the above example is:
std::cout << o ? o‐>c_str() : "fallback";
And no:
std::cout << o.value_or("fallback");
value_or() is an interface that makes the intent clearer, but the overhead may be a bit higher.
(2) Optional object of bool type or native pointer
Using the comparison operator when using optional objects as bool values has special semantics. This can lead to confusing behavior if the implicit type is a bool or pointer type. For example:
std::optional
if (!ob) ... // return false
if (ob == false) ... // return true
std::optional<int*> op{nullptr};
if (!op) ... // return false
if (op == nullptr) ... // return true