Are there drawbacks to using [[maybe_unused]] for variables used only in asserts?

Question

If a variable is only used in an assert, then compilers usually produce a warning when the program is compiled in release mode (i.e. without debug flags). This question suggests ways to disable these particular warnings. Among the answers, the C++17 attribute maybe_unused is suggested. However, these answers have not really been discussed.

Are there any drawbacks to using [[maybe_unused]] in situations like this one

[[maybe_unused]] const auto i = get_i();
assert(i == 5);

in order to silence the warning about i being unused in a release build?

if `get_i` has no side effects, if would probably use `assert(get_i() == 5);`. — Jarod42, May 26 '20 at 07:15
I thought there won't be any drawbacks as compiler are free to optimize ```i``` out. No reason not to do so right? — LIU Qingyuan, May 26 '20 at 07:30
On the other hand, if `i` is not some trivial type adding `maybe_unused` attribute won't allow compiler to optimize it away, only silence the warning. — user7860670, May 26 '20 at 07:35

score 0 · Answer 1 · answered Jul 20 '20 at 14:34

The problem with such a suggestion is that they might cause some overhead without a warning, especially after some refactoring.

Only the content/expression inside of an assert is usually completely removed in release builds.

If you want to use variables in your assert, you can use lambdas. See this example:

#include <cassert>

auto get_i(){
    return 5;
}

int main(){
    /* BAD
    [[maybe_unused]] const auto i = get_i();
    assert(i == 5);
    */
    
    assert([&](){
        const auto i = get_i();
        return i == 5;
    }());
}

Are there drawbacks to using [[maybe_unused]] for variables used only in asserts?

1 Answers1