In C++, we insert the string into the output stream. In this case, we insert a string into the standard output.

#include <iostream>

int main() {
    std::cout << "I'm a string" << std::endl;
    return 0;
}

The symbol << is an the insertion operator that’s overloaded by the C++ standard library. Unlike built-in operators which are translated by the compiler, overloaded operators are declared and defined by a function.

Here’s the declaration of the function operator<<.

template<
    class CharT,
    class Traits,
    class Allocator
    >
std::basic_ostream<CharT, Traits>&
operator<<(
           std::basic_ostream<CharT, Traits>& os,
           const std::basic_string<CharT, Traits, Allocator>& str
           );

For this example, you can mentally reduce it to:

std::ostream& operator<<(std::ostream& os, const std::string& str);

Python supports default arguments directly. This is usually the simplest way to make an argument optional.

def greet(name="World", punctuation="!"):
    print("Hello, " + name + punctuation)

greet()
greet("Alice")
greet("Alice", "?")

This prints:

Hello, World!
Hello, Alice!
Hello, Alice?

When the absence of a value has a special meaning, Python commonly uses None.

def greet(name: str | None = None):
    if name is None:
        name = "World"

    print("Hello, " + name)

greet()
greet("Alice")

Here, the type

str | None

means that name may contain either a string or None.

Python also has @overload for static type checking, but it is normally used when different argument combinations produce different type signatures. It is usually unnecessary just to make an ordinary argument optional.

def greet(name="World"):
    print("Hello, " + name)

is therefore generally preferable to trying to simulate function overloading.

Lua handles function arguments differently from Python and C++.

Every ordinary function parameter in Lua is effectively optional.

If an argument is not provided, its corresponding parameter receives nil.

local function greet(name, punctuation)
    print(name)
    print(punctuation)
end

greet()

This behaves approximately as though Lua had called:

greet(nil, nil)

Because of this, Lua does not need special syntax for optional parameters.

You usually check for nil and provide the default yourself.

local function greet(name, punctuation)
    if name == nil then
        name = "World"
    end

    if punctuation == nil then
        punctuation = "!"
    end

    print("Hello, " .. name .. punctuation)
end

greet()
greet("Alice")
greet("Alice", "?")

This prints:

Hello, World!
Hello, Alice!
Hello, Alice?

For values where false is not meaningful, Lua programmers will also commonly use or:

local function greet(name, punctuation)
    name = name or "World"
    punctuation = punctuation or "!"

    print("Hello, " .. name .. punctuation)
end

However, remember that Lua considers both nil and false to be false values.

For example, this can be wrong:

local function configure(enabled)
    enabled = enabled or true
end

If someone deliberately calls

configure(false)

then enabled or true produces true.

When false is a legitimate argument, explicitly check for nil instead:

local function configure(enabled)
    if enabled == nil then
        enabled = true
    end

    print(enabled)
end

configure()       -- true
configure(false)  -- false

Lua also permits extra arguments:

local function greet(name)
    print("Hello, " .. (name or "World"))
end

greet("Alice", 10, true)

If the function does not use ..., those additional arguments are simply not assigned to named parameters.

To deliberately accept an arbitrary number of arguments, Lua uses varargs:

local function printAll(...)
    for index, value in ipairs({...}) do
        print(index, value)
    end
end

printAll("Alice", 10, true)

So in Lua, “optional arguments” are not a separate language feature. They naturally result from Lua assigning nil to parameters whose arguments were omitted.

C does not have default arguments.

A function such as

void greet(const char *name);

must normally be called with exactly the arguments required by its declaration.

One common C technique is to use a sentinel value such as NULL to represent an omitted value:

#include <stdio.h>

void greet(const char *name)
{
    if (name == NULL) {
        name = "World";
    }

    printf("Hello, %s!\n", name);
}

int main(void)
{
    greet(NULL);
    greet("Alice");
}

Another common technique is to provide separate functions:

#include <stdio.h>

void greet(const char *name)
{
    printf("Hello, %s!\n", name);
}

void greet_default(void)
{
    greet("World");
}

int main(void)
{
    greet_default();
    greet("Alice");
}

C also supports variadic functions using ..., such as printf:

printf("%s is %d years old\n", "Alice", 15);

However, variadic arguments are generally not a replacement for ordinary optional parameters. They sacrifice type information and require the function to have some way to determine how many arguments were supplied and what their types are.

For ordinary APIs, explicit parameters, sentinel values, configuration structures, or additional helper functions are usually clearer.

C++ directly supports default arguments.

For simple optional parameters, this is usually the clearest solution.

#include <iostream>
#include <string_view>

void greet(
    std::string_view name = "World",
    std::string_view punctuation = "!"
)
{
    std::cout << "Hello, " << name << punctuation << '\n';
}

int main()
{
    greet();
    greet("Alice");
    greet("Alice", "?");
}

This prints:

Hello, World!
Hello, Alice!
Hello, Alice?

C++ also supports function overloading.

An overload is useful when different forms of an operation deserve separate interfaces rather than merely different default values.

#include <iostream>
#include <string_view>

void greet()
{
    std::cout << "Hello, World!\n";
}

void greet(std::string_view name)
{
    std::cout << "Hello, " << name << "!\n";
}

int main()
{
    greet();
    greet("Alice");
}

For a simple example like this, a default argument is usually less repetitive:

void greet(std::string_view name = "World");

C++ also provides std::optional when the presence or absence of a value is itself meaningful.

#include <iostream>
#include <optional>
#include <string>

void greet(const std::optional<std::string>& name = std::nullopt)
{
    if (name) {
        std::cout << "Hello, " << *name << "!\n";
    } else {
        std::cout << "Hello, mysterious stranger!\n";
    }
}

int main()
{
    greet();
    greet("Alice");
}

Here, std::nullopt means that no name was supplied.

A useful rule of thumb is:

• Use a default argument when there is an obvious normal default.
• Use an overload when different forms of the operation deserve distinct interfaces.
• Use std::optional<T> when “there is no value” is meaningful information that should be represented explicitly.