Как работает этот код для запрета наследования?

Если у вас есть наследство Protected или Private, вы не можете:

Base *ptr = new Derived();

ни ты не можешь сделать,

Derived *ptr1 = new Derived();
Base *ptr = ptr1;

Это потому, что Base является недоступной базой Derived.

Поскольку указатель класса Base не может указывать на объект класса Derived, эта проверка выглядит излишней.

EDIT:
Даже если вы не можете напрямую присвоить объект класса Derived указателю класса Base, это может произойти по-другому, например: если функция класса Derived возвращает указатель класса Base.

Короче говоря, указатель класса Base может указывать на объект класса Derived, даже если производным является protected или private.

Учитывая вышеизложенное,

Согласно стандарту C++:
5.2.7.8:

Проверка во время выполнения логически выполняется следующим образом:
— Если в самом производном объекте, на который указывает (ссылается) v, v указывает (ссылается) на общедоступный подобъект базового класса объекта T, и если только один объект типа T является производным от подобъекта, на который указывает (на который ссылается) v, результатом является указатель (ссылающееся на lvalue) на этот объект T.
— В противном случае, если v указывает (относится) к общедоступному подобъекту базового класса наиболее производного объекта, а тип наиболее производного объекта имеет базовый класс типа T, который является однозначным и public, результатом является указатель (отсылка к lvalue) к подобъекту T самого производного объекта.
— в противном случае проверка во время выполнения завершится ошибкой.

Обратите внимание, что стандарт специально требует, чтобы вывод был общедоступным
. Таким образом, dynamic_cast обнаружит обработку приведения как неправильное приведение, если вывод protected или private, и вернет NULL (поскольку вы используете указатель), и будет вызываться assert.

Так что да, код вполне действителен. И это действительно делает то, что говорится в комментарии

Этот образец демонстрирует, что он работает в соответствии с комментариями:

#include<iostream>
class Base 
{
    public:
        virtual bool IsDerived() const { return false; }
};

class Derived : protected Base 
{
    public:
        bool IsDerived() const { return true; }
        Base* getBase() { return this; }
};

Derived* CastToDerived( Base* base )
{
     // private and protected inheritance from Derived is prohibited
     Derived* derived = dynamic_cast<Derived*>(base);
     if( derived == 0 ) 
     {
         std::cout<< "!base->IsDerived()";
     }
     return derived;
}


int main()
{
    Derived *ptr3 = new Derived();
    Base *ptr = ptr3->getBase();
    Derived *ptr2 = CastToDerived(ptr);
    return 0;
}

IsDerived — это виртуальная функция, определенная в базовом классе, и функции разрешаются на основе статического типа объекта, с помощью которого вы вызываете функцию. Это значит, что это не проблема. Это будет работать. (Или, может быть, я что-то упустил в вашем вопросе).

dynamic_cast выполняет проверку во время выполнения (5.2.7/8).

Проверка во время выполнения завершится ошибкой, если Base наследуется как защищенный или закрытый Derived.

Значением неудачной проверки во время выполнения при приведении к указателю является указатель NULL (5.2.7/9).

Таким образом, код представляет собой обходной путь для частных и защищенных потомков: если вы наследуете Derived с protected или private, dynamic_cast вернет NULL и будет выполнена пользовательская проверка.

Я не понимаю отрывок о частном и защищенном наследовании.

Ответ прост. Этот комментарий, как и многие, многие другие комментарии, является комментарием, который никоим образом не описывает код, форму или форму.

Пример:

class PrivateDerived : private Derived {
public:
   Base* cast_to_base () {
      return dynamic_cast<Base*>(this);
   }   
};  

void check_base (const char * id, Base* pbase) {
   if (pbase == 0) {
      std::cout << id << " conversion yields a null pointer.\n";
   }
   else {
      std::cout << id << "->IsDerived() = "
                << pbase->IsDerived() << "\n";
      Derived* pderived = CastToDerived (pbase);
      std::cout << "CastToDerived yields "
                << (pderived ? "non-null" : "null") << " pointer.\n";
      std::cout << "pderived->IsDerived() = "
                << pderived->IsDerived() << "\n\n";
   }
}

int main () {
   PrivateDerived private_derived;

   // Good old c-style cast can convert anything to anything.
   // Maybe a bit disfunctional, but it works in this case.
   check_base ("c_style_cast", (Base*)&private_derived);

   // The cast_to_base method can see the private inheritance,
   // and does so without invoking undefined behavior.
   check_base ("cast_method", private_derived.cast_to_base());

   return 0;
}

Протестировано с несколькими версиями gcc и clang; ни один из них не поднял это утверждение assert.

Дополнение
Я подозреваю, что произошло то, что на какой-то конкретной машине с каким-то конкретным компилятором рассматриваемый код каким-то образом сумел сделать то, что, по мнению автора, он должен был делать. Я подозреваю, что автор никогда не проверял эту предполагаемую проверку, чтобы убедиться, что она действительно работает так, как рекламируется.