Default argument vs std::optional as an argument vs Function Overloading - c++

Question

Let's say I'm implementing a function func.
I have a use case where func will be invoked with two parameters.
I have another use case where func will be invoked with just one parameter but a default value of the missing second parameter will be used within the function.
I can think of 3 possible ways of implementing this functionality:
Default Argument
void func(int a, long b = c);
func will be invoked like this:
func(a);
func(a, b);
Function Overloading
void func(int a);
void func(int a, long b);
func will be invoked like this:
func(a);
func(a, b);
Using Optional as a function argument
void func(int a, optional<long> b);
func will be invoked like this:
func(a, optional<long> ());
func(a, b);
I want to know what's the best way of implementing the desired functionality. Any suggestions are welcome.

Answer 1

There are two questions to ask yourself when considering this:
Does the optional argument have a logical default?
Is the function implemented the same when the optional argument is given and when it's not?
If the second argument has a logical default and the function does the same thing no matter what, then a default argument works well. For example:
std::vector<std::string> split_string(const std::string& str, char sep = ' ');
By default, this splits a string on spaces, but the separator can be given to change that. It makes little sense to split this into two overloads or use a std::optional here.
If the second argument doesn't have a logical default but the function is still mostly the same if it isn't given, then std::optional makes more sense. For example:
void extract(const std::filesystem::path& archive_file,
const std::filesystem::path& output_dir,
std::optional<std::regex> exclude_filter = {});
Here we're extracting files from an archive file and writing the extracted files to disk, optionally excluding files that match some pattern. The function definition would be fundamentally the same with or without the filter; it's just one extra line difference:
if (exclude_filter && std::regex_match(file, *exclude_filter) continue;
It doesn't make much sense to duplicate the definition, so overloading doesn't really make sense. At the same time, there's no "don't match anything" regex, so there's not a logical default filter that could be applied. std::optional is a perfect fit here.
Note that I did still use a default argument. Defaulting your std::optional to be empty can make your calls much nicer.
Lastly, if the function implementation is fundamentally different between the one-arg and two-arg versions, then use an overload. For example:
void hide(window& win) {
win.set_visible(false);
}
template <typename rep, typename period>
void hide(window& win, const std::chrono::duration<rep, period>& fade_time) {
auto wait_time = equal_intervals(fade_time, win.opacity());
while (win.oapcity() > 0) {
win.set_opacity(win.opacity() - 1);
std::this_thread::sleep_for(wait_time);
}
}
Here we're hiding a window with an optional fade out time. While the functions logically do the same thing, they're implemented totally differently. Being the same function doesn't make a lot of sense. Even though 0 would be a logical default fade time, it still doesn't make sense to use a default argument here since you would just end up with a big if block:
if (fade_time == 0) {
// body of the first overload
} else {
// body of the second overload
}