std variant and forward declarations

Question

It's my understanding that std::variant cannot directly hold references.

However, std::reference_wrapper is a fully qualified type that can be put into things like std::vector, and since one can make a vector of reference wrappers, I imagined that one could do the same with std::variant.

The following (edited to be more minimal) code generates a plethora of errors in gcc:

#include <functional>
#include <variant>

class Foo;
class Baz;

template<typename T> struct CRef : std::reference_wrapper<const T> {
    CRef(const T &x) : std::reference_wrapper<const T>(x)
    {
    }
};    

template<typename... Args> struct Contains : public std::variant<CRef<Args>... > {
};

struct Foo : public Contains<Baz> {

    int getSize() const;
};

struct getSizeVisitor {

    template<typename T> int operator()(CRef<T> x) const
    {
        return sizeof(T);
    }
};

inline int Foo::getSize() const
{
    return std::visit(getSizeVisitor(), (*this));
}

struct Baz : public Foo {

};

The CRef template is simply a convenient wrapper around an std::reference_wrapper to a const reference, and the Contains template exists to help a class be made aware of all of the endpoint subclasses that the base class may at some point refer to. In the above case, I am simply wanting a getSize() method, which will return the size of the actual type contained in the variant. Baz, in this case, is the only endpoint class, although in practice there will be more, and they will have no common base class, which is why I require a variant, and cannot simply use a base class and employ virtual functions.

The errors generated by the compiler are visible here: https://godbolt.org/z/lcbPjB

So, I guess I'm probably doing something that isn't allowed.

The question I have is, is there a way to do what I'm trying? I apologize in advance if my intent is unclear. If there are problems understanding what I am trying to achieve, some feedback to that effect that specifically identifies what additional information I need to supply can be left and I shall endeavor to comply.

Bear in mind that in the actual use case, the endpoint classes are much more complex, and there will be many more functions beyond getSize(), but I expect once I have something working for this simple case, I should be able to generalize and implement the other functions correctly.

In the future, we do care about the "minimal" in [mcve]. There's a lot of code in this example that doesn't contribute to demonstrating the issue. Here's just commenting out a bunch of stuff: [example](https://godbolt.org/z/_3yDt3) (I did add one semicolon). — Barry, Oct 29 '19 at 11:58
Example is simplified, per your request. Your shorter reproduction identified one problem with the original, and I apologize profusely for the confusion. A different problem emerges even when I remove the call to CRef around *this in the visitor. — markt1964, Oct 29 '19 at 17:28

Barry · Accepted Answer · 2019-10-29T12:03:01.047

1

Here's a much shorter reproduction of the same issue:

int getSize(std::variant<int, char> var)
{
    return std::visit([](auto const& x){ return sizeof(x); },
        std::cref(var));
}

The problem is, you're trying to pass a reference_wrapper to std::visit... but that violates the requirements of std::visit - it needs take actual std::variants (in the original OP, the object is even more removed from std::variant - it's a reference wrapper of a type that inherits from a type that inherits from a std::variant - but the distance from variant doesn't matter).

You need to pass in the exact variant. In my short example, that's just passing var instead of std::cref(var). In the OP, that's casting *this down to variant<Ts...> const& for the correct types Ts...

edited Oct 29 '19 at 12:03

answered Oct 29 '19 at 11:54

Barry

286,269
29
621
977

While this does identify one problem with the code I had originally posted (which was mistakenly constructing a reference around the variant and passing that to std visit instead of passing the variant directly), removing that still reveals that there is something else I am doing that is wrong. – markt1964 Oct 29 '19 at 17:29
@markt1964 It's the same problem - you're passing something whose type is not `variant`. – Barry Oct 29 '19 at 17:56

std variant and forward declarations

1 Answers1