Is it okay to inherit from an std::variant in order to make it recursive?

Question

This question comes out of a reddit thread about an Advent of Code problem from last year.

I had mentioned that the only way to make an std::variant recursive was to wrap it in a struct so you can forward declare the struct as there is no way to forward declare an instantiation of a template, e.g.

struct wrapped_list;
using list = std::variant<int, std::vector<wrapped_list>>;
struct wrapped_list {
    list val;
};

Some other poster suggested using inheritance rather than composition:

class List;

class List : public std::variant<int, std::vector<List>> {  
  public:  
    using base = std::variant<int, std::vector<List>>;  
    using base::base;  
    using base::operator=;  
};

which is better in the sense that you do not have to deal with a wrapper struct that serves no purpose other than satisfying syntax requirements for declaring the variant.

However, I am used to never inheriting from types in the standard library. Is the above declaration portable and legal C++? Is calling std::visit on such a variant officially undefined behavior? etc.

Yes, looks legal to me. The manual for `std::visit` specifically mentions supporting types derived from `variant`. — HolyBlackCat, Jun 07 '23 at 19:01
I misunderstood the question, I mistook `std::vector` for `std::variant`. I thought the `std::variant` had itself as a possible member. — François Andrieux, Jun 07 '23 at 19:24

score 2 · Accepted Answer · answered Jun 07 '23 at 19:14

Is the above declaration portable and legal C++?

Yes.

Is calling std::visit on such a variant officially undefined behavior?

No, there's no problem doing that. You could implement the visitor to call itself recursively for example:

struct visitor {
    void operator()(int x) const { std::cout << x << '\n'; }
    
    void operator()(const std::vector<List>& l) const {
        for(auto& v : l) std::visit(*this, v);
    }
};

Demo

(The recursive visitor will be possible to simplify in C++23 with deducing this)

Is it okay to inherit from an std::variant in order to make it recursive?

1 Answers1