boost variant with custom classes

Question

I was trying boost-variant with custom classes. I understood that a safe way to access the content of a class is using boost::static_visitor. Do you know why the code below doesn't compile? Are there any requirement on the signature/declaration of boost::static_visitor in order to be used?

I found this question Why can't I visit this custom type with boost::variant? but I didn't get it.

Regards

AFG

#include <iostream>
#include <algorithm>
#include <boost/variant.hpp>

struct CA{};

struct ca_visitor : public boost::static_visitor<CA>
{
    const CA& operator()(const CA& obj ) const { return obj;}
};

struct CB{};

struct cb_visitor : public boost::static_visitor<CB>
{
    const CB& operator()(const CB& obj) const { return obj;}
};

int main(){   
    typedef  boost::variant< 
        CA  
        ,CB >  v_type;

    v_type v;
    const CA& a = boost::apply_visitor( ca_visitor(), v );
}

Andy Prowl · Accepted Answer · 2013-03-03T15:19:53.843

First of all, the template argument of boost::static_visitor<> should specify the type returned by the call operator. In your case, ca_visitor's call operator returns a CA const&, not a CA.

But that is not the biggest issue. The biggest issue is that you seem to have a misconception of how variant<> and static_visitor<> should work.

The idea of a boost::variant<> is that it can hold values of any of the types you specify in the template argument list. You don't know what that type is, and therefore you provide a visitor with several overloaded call operators for handling each possible case.

Therefore, when you provide a visitor, you need to make sure it has all necessary overloads of operator() that accept the types your variant can hold. If you fail to do so, Boost.Variant causes a compilation error to be generated (and is doing you a favor, because you forgot to handle some cases).

This is the issue you are facing: your visitor does not have a call operator accepting an object of type CB.

This is an example of a correct use of boost::variant<> and static_visitor<>:

#include <iostream>
#include <algorithm>
#include <boost/variant.hpp>

struct A{};
struct B{};

struct my_visitor : public boost::static_visitor<bool>
//                                               ^^^^
//                                               This must be the same as the
//                                               return type of your call 
//                                               operators
{
    bool operator() (const A& obj ) const { return true; }
    bool operator() (const B& obj) const { return false; }
};

int main()
{
    A a;
    B b;
    my_visitor mv;

    typedef boost::variant<A, B> v_type;

    v_type v = a;

    bool res = v.apply_visitor(mv);
    std::cout << res; // Should print 1

    v = b;

    res = v.apply_visitor(mv);
    std::cout << res; // Should print 0
}

The type by type kind of visitation can be implemented via `T* v = get(var);` where `v` is `nullptr` if the `var` is not of type `T`. Note that this is brittle. — Yakk - Adam Nevraumont, Mar 03 '13 at 15:35
@Yakk: Indeed, but it seems to me the OP was asking what's the proper usage of a visitor. — Andy Prowl, Mar 03 '13 at 15:37
Sure: but I figure showing them how to "visit" the way they expected visiting to work might be useful: few who do not know the answer know what to ask. — Yakk - Adam Nevraumont, Mar 03 '13 at 15:47
@Andy/@Yakk: Thanks for your response. While reading your explanations I started also thinking about the meaning of variant and its visitor. It appears to me more like a class with the 'constraint' of containing a single member of each possible type and static_visitor as getters checked at compile time. Is this a too narrow-minded thinking? BOOST presents it like a C-Union, but member of it share the same memory space...so in which domain or context do you and Yakk use variants?(maybe this is a different question in the forum) — Abruzzo Forte e Gentile, Mar 03 '13 at 16:04
@AbruzzoForteeGentile: I think more or less you got it. I generally use variants when I need to achieve non-intrusive compile-time polymorphism, i.e. when I do not want or cannot use virtual functions to differentiate the behavior of an algorithm based on the run-time type of the object it operates on. — Andy Prowl, Mar 03 '13 at 16:12

boost variant with custom classes

1 Answers1