Блог

Я склонен любить простые решения, поэтому я бы выбрал подход со свободной функцией, возможно, добавив SFINAE, чтобы отключить функцию для типов, отличных от Aggregate :

 template <typename Visitor, typename T>
typename std::enable_if< std::is_same<Aggregate,
                                   typename std::remove_const<T>::type 
                                  >::value
                       >::type
visit( Visitor amp; v, T amp; s ) {  // T can only be Aggregate or Aggregate const
    v(s.i);
    v(s.d);   
}
  

Где enable_if , is_same и remove_const на самом деле просты в реализации, если у вас нет компилятора с поддержкой C 0x (или вы можете позаимствовать их у boost type_traits)

РЕДАКТИРОВАТЬ: при написании подхода SFINAE я понял, что существует немало проблем при предоставлении простого шаблонного (без SFINAE) решения в OP, которые включают в себя тот факт, что если вам нужно предоставить более одного доступных для посещения типов, разные шаблоны будут сталкиваться (т. Е. Они будут одинаково хорошо совпадатькак и другие). Предоставляя SFINAE, вы фактически предоставляете visit функцию только для типов, которые выполняют условие, преобразуя странные SFINAE в эквивалент:

 // pseudocode, [] to mark *optional*
template <typename Visitor>
void visit( Visitor amp; v, Aggregate [const] amp; s ) {
   v( s.i );
   v( s.d );
}
  

 struct Aggregate
{
    int i;
    double d;

    template <class Visitor>
    void operator()(Visitor amp;v)
    {
        visit(this, v);
    }
    template <class Visitor>
    void operator()(Visitor amp;v) const
    {
        visit(this, v);
    }
  private:
    template<typename ThisType, typename Visitor>
    static void visit(ThisType *self, Visitor amp;v) {
        v(self->i);
        v(self->d);
    }
};
  

Хорошо, итак, все еще есть некоторый шаблон, но нет дублирования кода, который зависит от фактических членов агрегата. И в отличие от const_cast подхода, поддерживаемого (например) Скоттом Мейерсом, чтобы избежать дублирования в геттерах, компилятор обеспечит постоянную корректность обеих общедоступных функций.

Поскольку ваши конечные реализации не всегда идентичны, я не думаю, что существует реальное решение вашей предполагаемой «проблемы».

Давайте подумаем об этом. Мы должны учитывать ситуации, когда Aggregate значение является либо const, либо non-const . Конечно, мы не должны ослаблять это (например, предоставляя только неконстантную версию).

Теперь постоянная версия оператора может вызывать только посетителей, которые принимают свой аргумент по const-ref (или по значению), в то время как непостоянная версия может вызывать любого посетителя.

Вы можете подумать, что можете заменить одну из двух реализаций другой. Для этого вы всегда должны реализовывать версию const в терминах неконстантной версии, а не наоборот. Гипотетически:

 void operator()(Visitor amp; v) { /* #1, real work */ }

void operator()(Visitor amp; v) const
{
  const_cast<Aggregate *>(this)->operator()(v);  // #2, delegate
}
  

Но для того, чтобы это имело смысл, строка # 2 требует, чтобы операция логически не изменялась. Это возможно, например, в типичном операторе доступа к члену, где вы предоставляете либо постоянную, либо непостоянную ссылку на некоторый элемент. Но в вашей ситуации вы не можете гарантировать, что operator()(v) вызов не мутирует *this !

Таким образом, ваши две функции действительно довольно разные, хотя они выглядят формально похожими. Вы не можете выразить одно в терминах другого.

Может быть, вы можете увидеть это по-другому: ваши две функции на самом деле не совпадают. В псевдокоде они:

 void operator()(Visitor amp; v) {
  v( (Aggregate *)->i );
  v( (Aggregate *)->d );
}

void operator()(Visitor amp; v) const {
  v( (const Aggregate *)->i );
  v( (const Aggregate *)->d );
}
  

На самом деле, если подумать об этом, возможно, если вы захотите немного изменить подпись, что-то можно сделать:

 template <bool C = false>
void visit(Visitor amp; v)
{
  typedef typename std::conditional<C, const Aggregate *, Aggregate *>::type this_p;
  v(const_cast<this_p>(this)->i);
  v(const_cast<this_p>(this)->d);
}

void operator()(Visitor amp; v) { visit<>(v); }
void operator()(Visitor amp; v) const { const_cast<Aggregate *>(this)->visit<true>()(v); }
  

Обычно в таких случаях, возможно, лучше использовать методы, которые имеют смысл. Например, load() и save() . Они говорят что-то конкретное об операции, которая должна выполняться через посетителя. Обычно предоставляется как const, так и неконстантная версия (в любом случае, для таких вещей, как средства доступа), так что это только кажется дублированием, но может избавить вас от некоторой головной боли при отладке позже. Если вам действительно нужен обходной путь (который я бы не советовал), это объявить метод const и все члены mutable .

Добавьте признак посетителя, чтобы указать, модифицируется он или нет (постоянное или неконстантное использование). Это используется итераторами STL.

Вы могли бы использовать const_cast и изменить сигнатуру метода VisitorRead, чтобы он также принимал const Tamp; в качестве параметра, но я думаю, что это уродливое решение.

Другое решение — потребовать Visitor , чтобы у класса была метафункция, которая добавляет const , когда она применяется:

 template <class Visitor>
static void visit(Visitor amp;v, typename Visitor::ApplyConst<Aggregate>::Type amp;a)
{
    v(a.i);
    v(a.d);
}