C/C++

Here’s a template for returning a std::optional from a function:

#include <optional>
// Remember to compile with --std=c++17 or equivalent

std::optional<double> myOptionalFunction() {
    auto myValue = /* ... */;
    if(myValue.IsNull()) {
        // We don't have a value
        return std::nullopt; // .has_value() => false
    }
    // We have a value, so return the value
    return myValue.AsDouble(); // .has_value() => true
}

std::nullopt is the easy way to return no value as a std::optional. Using this method instead of the default constructor (return std::optional<double>() in this case) you don’t explicitly have to enter the full qualified name including template argument (optional<double> if you use namespace std;). It’s much easier to read and copy&paste this way.

In the last line we can just return a double (myValue.AsDouble() in this example). Why? Because this will implicitly call the implicit constructor of std::optional<double>(const double& value) and therefore convert your double into a std::optional<double>() instance.

Usage example:

#include // std::optional
#include  // std::cerr, std::endl

using namespace std;

std::optional myOptionalFunction() {
    /* Your code goes here ! */
}

int main() {
    auto myOptionalValue = myOptionalFunction;
    if(myOptionalValue.has_value()) {
         // Print error message
         cerr << "The optional has no value!" << endl;
         return;
    }
    // Extract the value
    auto myValue = myOptionalValue.value();
    /* You can do something with myValue here! */
}

Alternatively you can use std::optional<T>::value_or() like this to give either the value or a default value:

#include <optional> // std::optional
#include <iostream> // std::cerr, std::endl

using namespace std;

std::optional<double> myOptionalFunction() {
    /* Your code goes here ! */
}

int main() {
    auto myOptionalValue = myOptionalFunction;
    const double defaultValue = 0.0;
    // Value will be 0.0 if myOptionalFunction() returned <no value>
    auto myValue = myOptionalValue.value_or(defaultValue);
    /* You can do something with myValue here! */
}

If your compiler shows you build errors like this:

/usr/include/opencascade/Font_FTLibrary.hxx:23:10: fatal error: ft2build.h: No such file or directory

you are missing the ft2build.h header file from libfreetype.

In order to install it on Ubuntu, use

sudo apt-get install libfreetype6-dev

If the error persists, you might want to add /usr/include/freetype2 to the include path. For GCC/G++, add

-I/usr/include/freetype2

to the command line arguments of the compiler.

If you use CMake, you can use a line like this in your CMakeLists.txt:

include_directories (/usr/include/freetype2)

To remove a file or directory (for example my-directory) use remove_all from the C++17 filesystem library:

remove_all("my-directory");

This will remove my-directory and all its sub-directories and files recursively.

Full example:

#include <experimental/filesystem>
using namespace std::experimental::filesystem;

int main() {
    remove_all("my-directory");
}

In case you are using GCC, you need to compile the file like this:

g++ -o delete-cpp17 delete-cpp17.cpp -lstdc++fs

You need to link the stdc++fs library so the functions from the C++17 filesystem library are available to your program.

If you just want to remove a file and don’t want to risk deleting an entire directory tree, use remove instead of remove_all or see our previous post How to delete file using C++17 filesystem library

To remove a file (for example test.txt) use remove from the C++17 filesystem library:

remove("test.txt");

Full example:

#include <experimental/filesystem>
using namespace std::experimental::filesystem;

int main() {
    remove("test.txt");
}

In case you are using GCC, you need to compile the file like this:

g++ -o delete-cpp17 delete-cpp17.cpp -lstdc++fs

You need to link the stdc++fs library so the functions from the C++17 filesystem library are available to your program.

Note that remove does not recursively remove directories! Use remove_all or see How to recursively delete directory using C++17 filesystem library

You can use is_regular_file to check any path (either a C++17 path object or just a string). Similarly you can use is_directory to check if the given path belongs to a directory.

Note that these just return false if the file or directory does not exist!

// Check if something is a file
bool isTestTxtAFile = is_regular_file("test.txt"); // true
bool isMyDirectoryAFile = is_regular_file("my-directory"); // false
bool isDoesNotExistAFile = is_regular_file("does-not-exist"); // false
// Check if something is a directory
bool isTestTxtADirectory = is_directory("test.txt"); // false
bool isMyDirectoryADirectory = is_directory("my-directory"); // true
bool isDoesNotExistADirectory = is_directory("does-not-exist"); // false

Note: To find out how to list a directory non-recursively, just replace recursive_directory_iterator by directory_iterator or see our full post How to list a directory using C++17 filesystem library.

To recursively list a directory using the C++17 filesystem library use this snippet:

#include <experimental/filesystem>

using namespace std::experimental::filesystem;

for(const directory_entry& entry : recursive_directory_iterator("my-directory")) {
    const auto& path = entry.path();
    // ...
}

Full example:

#include <iostream>
#include <string>
#include <experimental/filesystem>

using namespace std;
using namespace std::experimental::filesystem;

int main() {
    for(const directory_entry& entry : recursive_directory_iterator("my-directory")) {
        // Is it a file / directory?
        bool isNormalFile = is_regular_file(entry);
        bool isDirectory = is_directory(entry);

        auto path = entry.path();
        // Path: my-directory/test.txt
        string pathString = path.string();

        // Filename: test.txt
        string filenameString = path.filename().string();

        // Extension: txt
        string extensionString = path.extension().string();

        // NOTE: You can also "cout << path" directly
    }
}

Compile like this:

g++ -o filesystem-example filesystem-example.cpp -lstdc++fs

For this directory:

my-directory
├── subdirectory
│   └── subdir-test.txt
└── test.txt

this will list subdirectory , subdirectory/subdir-test.txt and test.txt.

To list a directory (non-recursively) using the C++17 filesystem library use this snippet:

#include <experimental/filesystem>

using namespace std::experimental::filesystem;

for(const directory_entry& entry : directory_iterator("my-directory")) {
    const auto& path = entry.path();
    // ...
}

Full example:

#include <iostream>
#include <string>
#include <experimental/filesystem>

using namespace std;
using namespace std::experimental::filesystem;

int main() {
    for(const directory_entry& entry : directory_iterator("my-directory")) {
        // Is it a file / directory?
        bool isNormalFile = is_regular_file(entry);
        bool isDirectory = is_directory(entry);

        auto path = entry.path();
        // Path: my-directory/test.txt
        string pathString = path.string();

        // Filename: test.txt
        string filenameString = path.filename().string();

        // Extension: txt
        string extensionString = path.extension().string();

        // NOTE: You can also "cout << path" directly
    }
}

Compile like this:

g++ -o filesystem-example filesystem-example.cpp -lstdc++fs

For this directory:

my-directory
├── subdirectory
│   └── subdir-test.txt
└── test.txt

this will only list subdirectory and test.txt

To get the filesize (in bytes) of any file (test.xml in our example) using the boost::filesystem library, use this snippet:

#include <experimental/filesystem>
#include <iostream>

using namespace std;
using namespace std::experimental::filesystem;

int main() {
    size_t filesize = file_size("test.xml");
    cout << filesize << endl;
}

You need to link the boost_filesystem and the boost_system libraries, i.e. compile like this:

g++ -o test test.cpp -lboost_filesystem -lboost_system

To get the filesize (in bytes) of any file (test.xml in our example) using only the C++17 filesystem library, use this snippet:

New version using filesystem:

#include <filesystem>
#include <iostream>

using namespace std;
using namespace std::filesystem;

int main() {
    size_t filesize = file_size("test.xml");
    cout << filesize << endl;
}

Old version using experimental/filesystem

#include <experimental/filesystem>
#include <iostream>

using namespace std;
using namespace std::experimental::filesystem;

int main() {
    size_t filesize = file_size("test.xml");
    cout << filesize << endl;
}

With GCC/G++ you need to link the stdc++fs library, i.e. compile like this:

g++ -o test test.cpp -lstdc++fs