У меня есть два базовых класса с использованием предложений

 class MultiCmdQueueCallback {
  using NetworkPacket  = Networking::NetworkPacket;
  ....
 }


 class PlcMsgFactoryImplCallback {
   using NetworkPacket = Networking::NetworkPacket;
  ....
 }

Затем я объявляю класс

class PlcNetwork : 
  public RouterCallback, 
  public PlcMsgFactoryImplCallback, 
  public MultiCmdQueueCallback {
  private:
    void sendNetworkPacket(const NetworkPacket &pdu);
}

затем компилятор помечает ссылку на ошибку «NetworkPacket» неоднозначно «sendNetworkPacket (NetworkPacket & ...»

Теперь оба «использующих предложения» относятся к одному базовому классу Networking: NetworkPacket

и фактически, если я заменю объявление метода на:

 void sendNetworkPacket(const Networking::NetworkPacket &pdu);

он компилируется нормально.

Почему компилятор рассматривает каждое предложение using как отдельный тип, даже если они оба указывают на один и тот же базовый тип. Это предписано стандартом или у нас есть ошибка компилятора?

Перед просмотром псевдонима результирующий тип (и доступность)

мы смотрим на имена

и действительно,

NetworkPacket возможно

• MultiCmdQueueCallback::NetworkPacket
• или PlcMsgFactoryImplCallback::NetworkPacket

То, на что они оба указывают, не Networking::NetworkPacketимеет значения.

Мы делаем разрешение имени, что приводит к неоднозначности.

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

class PlcNetwork : 
  public RouterCallback, 
  public PlcMsgFactoryImplCallback, 
  public MultiCmdQueueCallback {

using NetworkPacket= PlcMsgFactoryImplCallback::NetworkPacket; // <<< add this line
private:
    void sendNetworkPacket(const NetworkPacket &pdu);

}

Компилятор ищет только определения в базовых классах. Если в обоих базовых классах присутствует один и тот же тип и / или псевдоним, он просто жалуется, что не знает, какой из них использовать. Неважно, будет ли результирующий тип одинаковым или нет.

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

Из документов :

Объявление псевдонима типа вводит имя, которое может использоваться как синоним для типа, обозначенного как type-id. Он не вводит новый тип и не может изменить значение имени существующего типа.

Хотя эти два usingпредложения представляют один и тот же тип, у компилятора есть два варианта в следующей ситуации:

void sendNetworkPacket(const NetworkPacket &pdu);

Можно выбрать между:

• MultiCmdQueueCallback::NetworkPacket а также
• PlcMsgFactoryImplCallback::NetworkPacket

потому что он наследует от обоих MultiCmdQueueCallbackи PlcMsgFactoryImplCallbackбазовых классов. Результатом разрешения имени компилятора является ошибка неоднозначности, которая у вас есть. Чтобы это исправить, вам нужно явно указать компилятору использовать тот или иной код:

void sendNetworkPacket(const MultiCmdQueueCallback::NetworkPacket &pdu);

или

void sendNetworkPacket(const PlcMsgFactoryImplCallback::NetworkPacket &pdu);

Есть две ошибки:

1. Доступ к псевдонимам частного типа
2. Неоднозначная ссылка на псевдонимы типов

частный частный

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

государственно-общественного

Если вы измените видимость обоих MultiCmdQueueCallback::NetworkPacketи PlcMsgFactoryImplCallback::NetworkPacketлибо на общедоступные, либо на защищенные, то вторая проблема (неоднозначность) очевидна - это два псевдонима разных типов, хотя они имеют один и тот же базовый тип данных. Некоторые могут подумать, что «умный» компилятор может решить эту проблему (конкретный случай), но имейте в виду, что компилятор должен «мыслить в общем» и принимать решения на основе глобальных правил, а не делать исключения для конкретного случая. Представьте себе следующий случай:

class MultiCmdQueueCallback {
    using NetworkPacketID  = size_t;
    // ...
};


class PlcMsgFactoryImplCallback {
    using NetworkPacketID = uint64_t;
    // ...
};

Должен ли компилятор относиться к обоим NetworkPacketIDодинаково? Точно нет. Потому что в 32-битной системе size_tона 32-битная, а uint64_tвсегда 64-битная. Но если мы хотим, чтобы компилятор проверял базовые типы данных, он не мог бы различить их в 64-битной системе.

государственно-частного

Я полагаю, что этот пример не имеет никакого смысла в сценарии использования OP, но так как здесь мы решаем проблемы в целом, давайте рассмотрим, что:

class MultiCmdQueueCallback {
private:
    using NetworkPacket  = Networking::NetworkPacket;
    // ...
};

class PlcMsgFactoryImplCallback {
public:
    using NetworkPacket  = Networking::NetworkPacket;
    // ...
};

Я думаю, что в этом случае компилятор должен рассматривать PlcNetwork::NetworkPacketкак, PlcMsgFactoryImplCallback::NetworkPacketпотому что у него нет других вариантов. Почему он до сих пор отказывается это сделать и обвиняет в неопределенности, для меня загадка.