Eu tenho duas classes base com cláusulas de uso

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


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

Declaro uma classe

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

o compilador sinaliza uma referência de erro para 'NetworkPacket' é ambígua 'sendNetworkPacket (NetworkPacket & ...'

Agora, ambas as 'cláusulas de uso' resolvem a mesma classe subjacente Rede: NetworkPacket

e, de fato, se eu substituir a declaração do método por:

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

compila bem.

Por que o compilador trata cada cláusula de uso como um tipo distinto, embora ambos apontem para o mesmo tipo subjacente. Isso é obrigatório pelo padrão ou temos um bug do compilador?

Antes de analisar o tipo resultante de alias, (e acessibilidade)

olhamos para nomes

e realmente,

NetworkPacket pode ser

• MultiCmdQueueCallback::NetworkPacket
• ou PlcMsgFactoryImplCallback::NetworkPacket

O fato de ambos apontarem Networking::NetworkPacketé irrelevante.

Nós fazemos a resolução do primeiro nome, o que resulta em ambiguidade.

Você pode resolver a ambiguidade simplesmente selecionando manualmente qual deseja usar.

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

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

}

O compilador procura apenas as definições nas classes base. Se o mesmo tipo e ou alias estiver presente nas duas classes base, ele simplesmente reclama que não sabe qual usar. Não importa se o tipo resultante é o mesmo ou não.

O compilador procura apenas nomes na primeira etapa, totalmente independente se esse nome for uma função, tipo, alias, método ou qualquer outra coisa. Se os nomes forem ambíguos, nenhuma ação adicional será feita a partir do compilador! Simplesmente reclama com a mensagem de erro e para. Portanto, basta resolver a ambiguidade com a instrução using fornecida.

Dos documentos :

Uma declaração de alias de tipo introduz um nome que pode ser usado como sinônimo para o tipo indicado por id de tipo. Ele não introduz um novo tipo e não pode alterar o significado de um nome de tipo existente.

Embora essas duas usingcláusulas representem o mesmo tipo, o compilador tem duas opções na seguinte situação:

void sendNetworkPacket(const NetworkPacket &pdu);

Pode escolher entre:

• MultiCmdQueueCallback::NetworkPacket e
• PlcMsgFactoryImplCallback::NetworkPacket

porque herda das classes base MultiCmdQueueCallbacke PlcMsgFactoryImplCallback. Um resultado da resolução de nomes do compilador é o erro de ambiguidade que você possui. Para corrigir isso, você precisa instruir explicitamente o compilador a usar um ou outro como este:

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

ou

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

Existem dois erros:

1. Acessando Aliases de Tipo Privado
2. Referência ambígua aos aliases de tipo

privado-privado

Não vejo um problema que o compilador reclame primeiro sobre o segundo problema, porque o pedido realmente não importa - é necessário corrigir os dois problemas para prosseguir.

público-público

Se você alterar a visibilidade de ambos MultiCmdQueueCallback::NetworkPackete PlcMsgFactoryImplCallback::NetworkPacketpara público ou protegido, o segundo problema (ambiguidade) é óbvio - esses são dois aliases de tipo diferentes, embora tenham o mesmo tipo de dados subjacente. Alguns podem pensar que um compilador "inteligente" pode resolver isso (um caso específico) para você, mas lembre-se de que o compilador precisa "pensar em geral" e tomar decisões com base em regras globais em vez de fazer exceções específicas a cada caso. Imagine o seguinte caso:

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


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

O compilador deve tratar NetworkPacketIDos mesmos? Claro que não. Porque em um sistema de 32 bits, ele size_té de 32 bits e uint64_tsempre de 64 bits. Mas, se quisermos que o compilador verifique os tipos de dados subjacentes, não será possível diferenciá-los em um sistema de 64 bits.

público Privado

Acredito que este exemplo não faz sentido no caso de uso do OP, mas como aqui estamos resolvendo problemas em geral, vamos considerar o seguinte:

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

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

Penso que, neste caso, o compilador deve tratar PlcNetwork::NetworkPacketcomo PlcMsgFactoryImplCallback::NetworkPacketse não tivesse outras opções. Por que ainda se recusa a fazê-lo e culpa pela ambiguidade é um mistério para mim.