Используя C++, как я правильно наследовался тому же базовому классу дважды?

Непосредственно за этим стоит функция виртуального наследования на C++. То, что вы здесь делаете - это кошмар с обслуживанием. Возможно, это не будет большим сюрпризом, так как известные авторы, такие как H. Sutter, уже давно выступают против такого использования наследования. Но это происходит из непосредственного опыта работы с таким кодом. Избегайте глубоких цепочек наследования. Очень бойтесь ключевого слова protected - его использование очень ограничено. Подобный дизайн быстро выходит из-под контроля - отследить паттерны доступа к защищенной переменной где-то вверх по цепочке наследования из классов более низкого уровня становится сложно, обязанности частей кода становятся расплывчатыми и т.д., а люди, которые год спустя будут смотреть на ваш код, будут вас ненавидеть :)

Вы находитесь в C++, вы должны быть дружелюбны к шаблонам. Используя шаблон-аргумент-в-основном-классе, Вам не понадобится многократное наследование или избыточная реализация. Все будет выглядеть следующим образом:

class Foobar {};

template <typename Base> class UnixFoobarAspect : public Base {};
template <typename Base> class WindowsFoobarAspect : public Base {};
template <typename Base> class FoobarClientAspect : public Base {};
template <typename Base> class FoobarServerAspect : public Base {};

typedef UnixFoobarAspect<FoobarClientAspect<Foobar>/*this whitespace not needed in C++0x*/> UnixFoobarClient;
typedef WindowsFoobarAspect<FoobarClientAspect<Foobar> > WindowsFoobarClient;
typedef UnixFoobarAspect<FoobarServerAspect<Foobar> > UnixFoobarServer;
typedef WindowsFoobarAspect<FoobarServerAspect<Foobar> > WindowsFoobarServer;

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

Посмотрите на этот поиск . Наследование Diamond - это в некотором роде претенциозный вопрос, и правильное решение зависит от конкретной ситуации.

Хотелось бы прокомментировать Unix/Windows сторону вещей. Обычно выходят #ifndef вещи, которые не подходят для конкретной платформы. Таким образом, вы получите только Foobar, скомпилированный для Windows или Unix с использованием директив препроцессора, а не UnixFoobar и WindowsFoobar. Посмотрите, как далеко вы можете зайти в использовании этой парадигмы, прежде чем исследовать виртуальное наследование.

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

Однако, это один из плохих случаев использования множественного наследования, который может доставить вам много трудностей. Скорее всего, вы не хотите, чтобы все было именно так.

Скорее всего, вы хотите, чтобы foobar наследовали по отдельности, чтобы каждый подкласс имел foobar, чтобы foobar был чистым виртуальным классом, или чтобы производный класс имел то, что он определяет или даже определяет foobar по отдельности.

Попробуйте этот пример состава и наследования:

class Client_Base;
class Server_Base;

class Foobar
{
  Client_Base * p_client;
  Server_Base * p_server;
};

class Windows_Client : public Client_Base;
class Windows_Server : public Server_Base;

class Win32 : Foobar
{
  Win32()
  {
    p_client = new Windows_Client;
    p_server = new Windows_Server;
  }
};

class Unix_Client : public Client_Base;
class Unix_Server : public Server_Base;

class Unix : Foobar
{
  Unix()
  {
    p_client = new Unix_Client;
    p_server = new Unix_Server;
  }
};

Многие эксперты говорили, что вопросы могут быть решены с помощью другого уровня бездействия.

Нет ничего "противозаконного" в том, чтобы дважды иметь один и тот же базовый класс. Последний дочерний класс будет просто (буквально) иметь несколько копий базового класса как его часть (включая каждую переменную в базовом классе и т.д.). Однако это может привести к некоторым неоднозначным вызовам функций этого базового класса, которые, возможно, придется разрешить вручную. Это не похоже на то, что вы хотите.

Рассмотрим композицию вместо наследования.

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

Используйте виртуальное наследование, в объявлении FoobarClient , FoobarServer , WindowsFoobar и UnixFoobar , поместите слово виртуальный перед именем базового класса Foobar .

Это гарантирует, что всегда будет один экземпляр Foobar , независимо от того, сколько раз он появляется в вашей иерархии базовых классов.