Как реализовать класс интерфейса, используя идиому невиртуального интерфейса в С++?

Я думаю, что у вас неправильный шаблон NVI: http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Non-Virtual_Interface

Не уверен, что это решит вашу проблему.

class IFoo
{
    public:
       void method() { methodImpl(); }
    private:
       virtual void methodImpl()=0;
};

class FooBase : public IFoo // implement interface IFoo
{
    private:
        virtual void methodImpl();
};

Вот пример того, почему вы можете сделать это, используя читатель, который читает из XML, а другой из БД. Обратите внимание, что общая структура перемещена в readFromSource NVI, а нестандартное поведение перемещено в частный виртуальный getRawDatum. Таким образом, ведение журнала и проверка ошибок необходимы только в одной функции.

class IReader
{
  public:
    // NVI
    Datum readFromSource()
    {
       Datum datum = getRawDatum();
       if( ! datum.isValid() ) throw ReaderError("Unable to get valid datum");
       logger::log("Datum Read");
       return datum;
    }
  private:
    // Virtual Bits
    Datum getRawDatum()=0;
};

class DBReader : public IReader
{
  private:
    Datum getRawDatum() { ... }
};

class XmlReader : public IReader
{
   private:
     Datum getRawDatum() { ... }
};

Обычно причиной использования NVI (иногда также называемого «методом шаблона») является то, что производные классы должны изменять только часть поведения базового класса. Итак, что вы делаете, это:

class base {
  public:
    void f()
    {
      // do something derived classes shouldn't interfere with          
      vf();
      // do something derived classes shouldn't interfere with          
      vg();
      // do something derived classes shouldn't interfere with          
      vh();
      // do something derived classes shouldn't interfere with          
    }
  private:
    virtual void vf(); // might be pure virtual, too
    virtual void vg(); // might be pure virtual, too
    virtual void vh(); // might be pure virtual, too
};

Затем производные классы могут подключаться к f() в тех местах, для которых они предназначены, и изменять аспекты поведения f(), не нарушая его основного алгоритма.

Может сбивать с толку тот факт, что как только метод объявлен виртуальным в базовом классе, он автоматически становится виртуальным во всех производных классах, даже если там не используются ключевые слова virtual. Итак, в вашем примере оба метода FooBase являются виртуальными.

... чтобы запретить производным классам возможность переопределения общего поведения, реализованного в FooBase::method()...

Если вы можете избавиться от IFoo и просто начать иерархию с FooBase с невиртуальным method, это подойдет. Но похоже, что вы хотите разрешить прямым дочерним элементам IFoo переопределять method(), но запретить дочерним элементам FooBase переопределять его. Я не думаю, что это возможно.

Для этого вы можете использовать идиому pimpl:

class IFoo
{
    public:
        IFoo( boost::shared_ptr< IFooImpl > pImpl )
            : m_pImpl( pImpl )
        {}

        void method() { m_pImpl->method(); }
        void otherMethod() { m_pImpl->otherMethod(); }
    private:
        boost::shared_ptr< IFooImpl > m_pImpl;
};

class IFooImpl
{
    public:
        void method();
        virtual void otherMethod();
};

Теперь другие все еще могут подклассировать IFooImpl и передать его IFoo, но они не могут переопределить поведение method (они могут переопределить otherMethod). Вы даже можете сделать IFooImpl прямым подклассом IFoo и использовать enable_shared_from_this< /a> для правильной инициализации IFoo. Это только суть метода. Есть много способов изменить этот подход. Например, вы можете использовать фабричный шаблон, чтобы убедиться, что IFoo созданы правильно.

Надеюсь, это поможет.