C++ Правильно ли я понимаю полиморфизм?

Почти верно - рассмотрим это дерево наследования:

      Foo
     /   \
   Bar   Box

Если вы сейчас сделаете такой указатель:

Bar* barry = new Box();

Вы получите приятную ошибку компилятора, поскольку Box нельзя преобразовать в Bar. :)
Так что это только Foo<->Bar и Foo<->Box, никогда Bar<->Box. Затем, когда boxxy является указателем Box, он будет вызывать только функцию Box::F, если она предоставлена.
И, наконец, чтобы заставить подклассы реализовать определенную функцию, вы объявляете ее pure virtual, например так:

virtual void Func() = 0;
//   note this --- ^^^^

Теперь подклассы (в данном случае Bar и Box) должны реализовывать Func, иначе они не смогут скомпилироваться.

Да, правильный F() будет вызываться в зависимости от типа объекта, который вы создали с помощью указателя Foo.

Если бы boxxy был указателем Box, вы могли бы вызвать только его F() или F() одного из его производных классов, если вы не выполнили dynamic_cast для его родительского класса, а затем вызвали F().

Чтобы избежать необходимости реализации в базовом классе, вы определяете его как чистый виртуальный следующим образом:

class Foo
{
public:
    virtual void F() = 0; //notice the = 0, makes this function pure virtual.

};

А что изменится, если boxxy будет указателем Box?

Это позволит получить доступ к методам Box, не унаследованным от Foo. Указатель Box не может указывать на объекты Bar, поскольку Bar не является производным от Box.

А что произойдет, если производный класс не имеет переопределения для F()?

Он унаследует реализацию F() от базового класса.

Наконец, чтобы избежать реализации функции для базового класса, но при этом разрешить полиморфизм, вы просто пишете пустое тело функции и объявляете его виртуальным?

Это будет работать, но это неправильный способ реализации полиморфизма. Если вы не можете придумать конкретную реализацию виртуальной функции базового класса, сделайте эту функцию чисто виртуальной, не реализуйте ее как пустую функцию.

Если вы объявите Foo следующим образом

class Foo
{
private:
  Foo() {};
public:
  void func() const { std::cout << "Calling Foo::func()" << std::endl; }
};

и бар вот такой

class Bar : public Foo
{
private:
  Bar() {};
public:
  void func() const { std::cout << "Calling Bar::func()" << std::endl; }
};

тогда

Foo* bar = new Bar();
bar->func();

вызовет Foo::func().

Если вы объявите Foo следующим образом

class Foo
{
private:
  Foo() {};
public:
  virtual void func() const { std::cout << "Calling Foo::func()" << std::endl; } // NOTICE THE virtual KEYWORD
};

тогда

Foo* bar = new Bar();
bar->func();

вызовет Bar::func().

• Я правильно понимаю? Да, если функция была объявлена ​​как виртуальная.
• А что изменится, если boxxy будет указателем Box? Зависит от того, является ли функция виртуальной или нет. Виртуальная функция всегда будет вызывать правильную производную функцию; невиртуальная функция будет вызывать версию на основе типа указателя.
• А что произойдет, если производный класс не имеет переопределения для F()? Он будет использовать определение базового класса.
• Наконец, чтобы избежать реализации функции для базового класса, но при этом разрешить полиморфизм, вы просто пишете пустое тело функции и объявляете его виртуальным? Вы также можете объявить его чисто виртуальным: virtual void F() = 0. Любой класс, который намеревается быть воплощенным в объект, значительно переопределяет эту функцию и дает ей правильную реализацию.