Using std::visit on a class inheriting from std::variant - libstdc++ vs libc++

Question

Consider the following code snippet:

struct v : std::variant<int, std::vector<v>> { };

int main()
{
    std::visit([](auto){ }, v{0});
}

clang++ 7 with -stdlib=libc++ -std=c++2a compiles the code;
g++ 9 with -std=c++2a fails to compile the code, with the following error:
/opt/compiler-explorer/gcc-trunk-20180711/include/c++/9.0.0/variant:94:29: error: incomplete type 'std::variant_size' used in nested name specifier
```
 inline constexpr size_t variant_size_v = variant_size<_Variant>::value;

                         ^~~~~~~~~~~~~~
```

live example on godbolt.org

Are both implementations conforming to the Standard?
If not, what implementation is correct here, and why?

Not the downvoter, but `-std=c++2a` isn't C++17, it's the yet-to-be finished C++20. Did you mean to ask about that? — Caleth, Jul 12 '18 at 15:51
Without inheritance, both compile: [Demo](https://godbolt.org/g/NZPdwf). — Jarod42, Jul 12 '18 at 16:32
It is unrelated to "recursive variant", inheriting from simple `std::variant` produces same issue [Demo](https://godbolt.org/g/mnzcRL). — Jarod42, Jul 12 '18 at 16:35
Both downvote and a close vote are totally unexplainable to me. — SergeyA, Jul 12 '18 at 17:08
Obviously neither conforms to the non-existent [tag:C++2a] standard ;) — Yakk - Adam Nevraumont, Jul 12 '18 at 17:37
So all of the compilers used in the godbolt link in the question work now - but onlinegdb.com uses gcc 7 so it still doesn't work. — Jerry Jeremiah, Oct 05 '21 at 06:29
@Jarod42 I'm just curious how you would build a real visitor for your demo if you are going to call std::visit recursively. I can't figure out how to make this work: https://gcc.godbolt.org/z/chThrnPfY — Jerry Jeremiah, Oct 05 '21 at 07:05
@JerryJeremiah: Your structure doesn't have `variant` member. once done, your example should work with little change: [Demo](https://gcc.godbolt.org/z/s1nx15hjn). — Jarod42, Oct 05 '21 at 08:03
@Jarod42 Sorry. I don't know what I was thinking. I just took your demo and tried to use the visitor. I should have paid more attention.... — Jerry Jeremiah, Oct 05 '21 at 20:48

T.C. · Accepted Answer · 2018-07-12T17:41:43.783

17

[variant.visit] in C++17 doesn't use variant_size_v, but it does in the current working draft as a result of an editorial change. I don't see any indication that LWG reviewed the change before it went in, but it has looked at this part of the standard several times since then and has yet to object to it, so I'm going to postulate that it is in fact required.

Meanwhile, LWG issue 3052, which has been referred to LEWG, would explicitly require std::variant. When that issue is resolved - one way or the other - it should resolve this too.

edited Jul 12 '18 at 17:41

answered Jul 12 '18 at 17:21

T.C.

133,968
17
288
421

FWIW: Thomas and I decided this change was editorial under the interpretation that "all variants" has the obvious meaning of "specializations of `std::variant`." The fact that LWG referred 3052 to LEWG, indicates to me that we're not sure what the word "variants" means. – Casey Jul 13 '18 at 05:43

score 12 · Answer 2 · edited Jul 12 '18 at 16:39

12

Looks like it is a bug in gcc implementation. According to cppreference, it is called as if calling invoke on a std::get. std::get<> is defined for anything which is convertible to std::variant (since it accepts a std::variant argument by forwarding reference). Your structure is convertible to std::variant, and so std::get itself works on your structure in gcc.

The fact that the gcc implementation chose to use a std::variant_size as part of its implementation of visit is their implementation detail, and the fact that it doesn't (and shouldn't) work for your struct is irrelevant.

Conclusion: It is a bug in gcc due to an oversight in implementation.

edited Jul 12 '18 at 16:39

callyalater

3,102
8
20
27

answered Jul 12 '18 at 16:07

SergeyA

61,605
5
78
137

6

Citing cppreference for "is this legal" is questionable; in a question tagged [language-lawyer] it is just plain wrong. cppreference contains "how to use" information that is reasonable; for implementation quirks it contains "lies we tell to children". – Yakk - Adam Nevraumont Jul 12 '18 at 17:34
2

@Yakk-AdamNevraumont, I agree, but I listed it for convenience. C++ 17 standard is no different in this regards, it has effectively the same wording. – SergeyA Jul 12 '18 at 19:34

score 3 · Answer 3 · edited Nov 22 '19 at 00:50

I came across this issue as well recently. I kind of came up with a workaround which basically specialises variant_size and variant_alternative for the class that inherits from the variant..

link on godbolt

Its not pretty and it injects stuff into the std namespace. I'm not a metaprogramming expert (yet!) so its something I hacked together. Maybe someone else can improve on this?

#include <variant>
#include <string>
#include <vector>
#include <iostream>

#include <utility>
#include <type_traits>



using var = std::variant<int, bool, float, std::string>;

struct myvar : public var {
    using var::var;
    using var::operator=;

};

namespace std{

    template<>
    struct variant_size<myvar> : variant_size<var> {
    };

    template<std::size_t I>
    struct variant_alternative<I,myvar> :  variant_alternative<I,var> {
    };
}

int main(){

    constexpr int vs = std::variant_size<var>::value;

    myvar s = std::string{"boo!"}; 
    std::visit([](auto&& e){std::cout << e << "\n";}, s);
    std::cout << vs;
}

Using std::visit on a class inheriting from std::variant - libstdc++ vs libc++

3 Answers3

Linked