Why do tuples not get unused variable warnings?

Question

In the following example, compiling with -Wall, some of the unused variables are not warned about:

#include <tuple>

struct Foo
{
    int a, b;
};

struct Bar
{
    ~Bar() {}

    int a, b;
};

int three() { return 3; }

int main()
{
    Foo f0 {1, 2};
    Foo f1 {three(), 2};
    Bar b0 {1, 2};
    Bar b1 {three(), 2};
    std::tuple<int, int> p0 {1, 2};
    std::tuple<int, int> p1 {three(), 2};
}

• clang 12.0.1: bs and p1 don't get warnings
• gcc 11.2: bs and ps don't get warnings

Why don't these get warnings? Is there a way to mark the destructor of Bar such that it won't mask the warnings?

Answer 1

The compiler will do its best to flag unused variables, but this is difficult for non-trivial types, and both Bar and std::tuple<int, int> are non-trivial.

static_assert(std::is_trivial_v<Foo>);
static_assert(!std::is_trivial_v<Bar>);
static_assert(!std::is_trivial_v<std::tuple<int, int>>);

As is described in

• Bug 55203 - No unused warning for variables of non-trivial types

As the compiler cannot tell for sure in some cases, such as the ctor calling an external function, the only reasonable way of handling this I see is explicit tagging of types for which there should be an unused warning if only ctor/dtor are called for a variable. Here's my attempt at attribute warn_unused.

you could use GCC's warn_unused attribute if you want a -Wunused-variable to be emitted in case on the constructor and/or destructor of the variable of the non-trivial type is called.

struct __attribute__((warn_unused)) Bar {
    ~Bar() {}
    int a, b;
};

int main() {
    Bar b{1, 3}; // warning: unused variable 'b' [-Wunused-variable]
}