`std::ignore` vs `[[maybe_unused]]` vs `_`

[lefticus]

https://en.cppreference.com/w/cpp/utility/tuple/ignore

[YarikTH]

Some takes from personal experience:

gcc-7 warns if any of structure binding names weren't used and there is no place for [[maybe_unused]] anywhere inside SB
https://godbolt.org/z/1bsMG6nev

clang warns if any lambda capture was not used and there is no place for [[maybe_unused]] anywhere inside lambda capture list
https://godbolt.org/z/1qPobKc44

[JohelEGP]

Relevant: https://www.reddit.com/r/cpp/comments/y634ms/prefer_corelanguage_features_over_library/.

[lefticus]

https://compiler-explorer.com/z/78no47WY8

[LB--]

I tend to use std::ignore to silence warnings of unused parameters, since that is easier to do with conditional compilation than conditionally adding [[maybe_unused]] or conditionally removing the parameter name.

void platform::ensure_somethings_configured(std::string_view const configuration_hint)
{
    #if defined(SOME_PLATFORM)
    sp_config(configuration_hint);
    #else
    std::ignore = configuration_hint;
    #endif
}

For function return values, [[maybe_unused]] is good for when the returned value is only referenced in an assert or other conditional code or is useful in the debugger, and std::ignore is good for when it's never needed (not even for debugging).

NativeFileHandle::~NativeFileHandle() noexcept
{
    if(native_handle != INVALID_HANDLE_VALUE)
    {
        std::ignore = log::debug("closing native handle\n");
        ::SetLastError(ERROR_SUCCESS)
        [[maybe_unused]] ::BOOL const result = ::CloseHandle(native_handle);
        [[maybe_unused]] ::DWORD const error = ::GetLastError();
        assert(result != 0 && error == ERROR_SUCCESS);
    }
}

[lefticus]

Coming in Ep490

[fcolecumberri]

I just watched the video, I am not sure I agree with the “std::ignore cannot ignore only part” since you can do this:

#include <tuple>

[[nodiscard]] std::tuple<int, int, int> get_value();

int main ()
{
    auto [a, b, c] = get_value();
    std::ignore = a;
    std::ignore = c;
    return b;
}

I also have seen functions like:

void fun_name(int arg, int other_arg){
    // ToDo: Implement
    std::ignore = arg;
    std::ignore = other_arg;
}

Personally I like this because

• std::ignore is shorter than [[maybe_unused]]
• std::ignore linguistically speaking is actively stating that you are ignoring instead of “maybe”.
• std::ignore doesn't force you to a specific name like _.
• You don't toy with the function signature so you reduce the risk of changing something unintentionally and keeps git cleaner.