boost::variant and polymorphism in c++11

Question

I am experimenting with polymorphism and boost::variant in c++11

Here is the code

#include <iostream>
#include <boost/variant.hpp>
using namespace std;

class Polygon {
protected:
        int width, height;
public:
        void set_values (int a, int b)
        {
                width=a;
                height=b;
        }
};

class Rectangle: public Polygon {
public:
        Rectangle() {
                std::cout << "ctor rectangle" << std::endl;
        }

        int area()
        {
                return width*height;
        }
};

class Triangle: public Polygon {
public:
        Triangle() {
                std::cout << "ctor triangle" << std::endl;
        }
        int area()
        {
                return width*height/2;
        }
};


int main () {

        Triangle r;
        boost::variant<Rectangle, Triangle> container = r;
        int x = 4;
        int y = 5;
        if (container.type() == typeid(Rectangle)) {
                r.set_values(x,y);
                std::cout << r.area() << std::endl;
        } else if ( container.type() == typeid(Triangle)){
                r.set_values(x,y);
                std::cout << r.area() << std::endl;
        }

        return 0;


}

I am wondering if this is the best way to proceed. There is a repetition in the code (in main() function) where for every type (we get the type at runtime) we execute the same thing, ie set value and print the area.

Is there any better way to do this?

Answer 1

This is a helper class for when you want value-type variant based polymorphism.

template<class Base>
struct poly_ptr_t : boost::static_visitor<Base*> {
  template<class T>
  Base* operator()(T& t)const { return std::addressof(t); }

  template<class...Ts>
  Base* operator[](boost::variant<Ts...>& v) const {
    return boost::apply_visitor( *this, v );
  }
  template<class...Ts>
  Base const* operator[](boost::variant<Ts...> const& v) const {
    return boost::apply_visitor( *this, v );
  }
};

Use:

poly_ptr_t<Polygon> as_polygon;
int main() {
  boost::variant<Triangle, Rectangle> u(Triangle{});
  as_polygon[u]->set_values(x,y);
}

Now, area is a bit of a pain. Getting the parent Polygon won't help, because it doesn't have an area.

If we added

virtual int area() = 0;

to Polygon then

std::cout << as_polygon[v]->area();

suddenly works.

The alternative is a bit of a mess in C++11. In C++14 with appropriate boost support, we get:

std::cout << boost::apply_visitor( [](auto& e){return e.area();}, v );

or

boost::apply_visitor( [](auto& e){std::cout << e.area();}, v );

where we use a generic lambda to call area.

Or we can write an area visitor:

struct get_area : boost::static_visitor<int> {
  template<class T>
  int operator()(T& t)const{ return t.area(); }
};

now we can do this:

std::cout << boost::apply_visitor( get_area, v );

In none of these cases do we have the code repetition within main.

Answer 2

Don't use if-else constructs.

Take a look at boost. I typed a small and untested example below.

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

class my_visitor : public boost::static_visitor<void>
{
public:
    void operator()(Rectangle const & i) const
    {
        // do something here
    }

    void operator()(Triangle const & i) const
    {
        // do something here
    }
};

int main()
{
    boost::variant< Triangle, Rectangle > u(Triangle());
    boost::apply_visitor( my_visitor(), u );
}