Tengo un problema con la duplicación de código idéntico paraconst y noconst versiones. Puedo ilustrar el problema con algún código. Aquí hay dos visitantes de muestra, uno que modifica los objetos visitados y otro que no.

struct VisitorRead 
{
    template <class T>
    void operator()(T &t) { std::cin >> t; }
};

struct VisitorWrite 
{
    template <class T> 
    void operator()(const T &t) { std::cout << t << "\n"; }
};

Ahora hay un objeto agregado: tiene solo dos miembros de datos, pero mi código real es mucho más complejo:

struct Aggregate
{
    int i;
    double d;

    template <class Visitor>
    void operator()(Visitor &v)
    {
        v(i);
        v(d);
    }
    template <class Visitor>
    void operator()(Visitor &v) const
    {
        v(i);
        v(d);
    }
};

Y una función para demostrar lo anterior:

static void test()
{
    Aggregate a;
    a(VisitorRead());
    const Aggregate b(a);
    b(VisitorWrite());
}

Ahora, el problema aquí es la duplicación deAggregate::operator() paraconst y noconst versiones.

¿De alguna manera es posible evitar la duplicación de este código?

Tengo una solución que es esta:

template <class Visitor, class Struct>
void visit(Visitor &v, Struct &s) 
{
    v(s.i);
    v(d.i);
}

static void test2()
{
    Aggregate a;
    visit(VisitorRead(), a);
    const Aggregate b(a);
    visit(VisitorWrite(), b);
}

Esto significa que tampocoAggregate::operator() es necesario y no hay duplicación. Pero no me siento cómodo con el hecho de quevisit() es genérico sin mencionar el tipoAggregate.

¿Hay una mejor manera?