Modern C++: std::optional – DEV Community

Hey, I’m lastly began to proceed my sequence from less-known options of Trendy C++.

The Drawback

There are occasions if you wish to return a possible worth like NULL or some error to point an issue, for instance.

int check_name(std::string title) {
     if (title == "Tom")
         return 0;
     else
         return -1; //  Used to point invalid enter 
}

However, when calling this operate one must examine if -1 is returned or not in response to the enter.

code = check_name("Similar")
if (code == -1) {
    ...
}

Which makes the code unreadable and inconsistent if different values are returned in relaxation features.

That is the place std::non-compulsory involves the rescue!

std::non-compulsory

std::non-compulsory is a function launched in C++ 17 which is used to signify non-compulsory values i.e. the opportunity of having a price or not having a price in a type-safe method.

Syntax

std::non-compulsory<T> opt_var;

the place T represents the non-compulsory worth to be saved.

Strategies:

• has_value: checks whether or not the thing comprises a price
• worth: returns the contained worth
• value_or: returns the contained worth if obtainable, one other worth in any other case

Utilization

• Examine if one quantity can divide one other quantity or not

#embody <iostream>
#embody <non-compulsory>

std::non-compulsory<int> divide(int num1, int num2) {
    if (num2 != 0) {
        return num1/num2;
    }
    return std::nullopt; // Signifies no type-safe worth
}

int primary() {
    auto consequence = divide(10, 2); // To deduce into std::non-compulsory<int>, used to avoid wasting time 
    if (consequence.has_value()) {  // has_value checks if a type-value is returned
        std::cout << "Outcome: " << consequence.worth() << std::endl; // worth returns the worth as operate arguments are right
    } else {
        std::cout << "Division by zero" << std::endl;
    }

    return 0;
}

• Simplifying error dealing with; in eventualities the place you wish to learn a file, parse strings then convert them into integers and format them.

#embody <iostream>
#embody <fstream>
#embody <non-compulsory>
#embody <string>

std::non-compulsory<std::string> try_reading_file(const std::string& filename) { // const to verify it does not get modified
    std::ifstream file(filename); // std::ifstream for studying information 
    if (!file.is_open()) {  // if file can't be opened
        return std::nullopt;
    }

    std::string content material((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>()); //Written the content material contained in the file
    return content material;
}

int primary() {
    const std::string filename = "exmpl.txt";

    // attempt to learn the file
    auto fileContent = try_reading_file(filename);

    if (fileContent.has_value()) {
        std::cout << "File content material:n" << fileContent.worth() << std::endl;
    } else {
        std::cerr << "Error: Couldn't open the file " << filename << std::endl;
    }

    return 0;
}

• Checking and altering the default worth

#embody <non-compulsory>
#embody <iostream>

int primary() {
    std::non-compulsory<int> worth;

    int consequence = worth.value_or(42);  // Assigns 42 if worth isn't current

    std::cout << "Outcome: " << consequence << std::endl;

    return 0;
}

These are the commonest usages of std::non-compulsory and extra usages can seen by studying C++ code of many open supply organizations.

Comparability from different languages

• Rust has an Choice enum to implement optionals
• Go does not have non-compulsory so it makes use of a kind referred to as error for error dealing with
• Java additionally implements non-compulsory through generics/lessons
• V implements possibility for returning non-compulsory values and consequence for resultant values.

Conclusion

Everytime you presumably must denote an reply or value-or-not-value, it is strongly recommended to make use of std::non-compulsory until you might be working with legacy code the place integers are used to signify. It additionally will increase the capability to describe complicated issues, readability and likewise deal with errors gracefully.

Code

All of the code used on this article is on the market on this repo.