Ho due classi base con l'utilizzo di clausole

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


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

Dichiaro quindi una classe

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

il compilatore quindi contrassegna un riferimento di errore a "NetworkPacket" è ambiguo "sendNetworkPacket (NetworkPacket & ..."

Ora entrambe le "clausole using" si risolvono nella stessa classe sottostante Networking: NetworkPacket

e infatti se sostituisco la dichiarazione del metodo con:

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

si compila bene.

Perché il compilatore tratta ciascuna clausola using come un tipo distinto anche se entrambi indicano lo stesso tipo sottostante. Questo è obbligatorio per lo standard o abbiamo un bug del compilatore?

Prima di esaminare l'alias risultante, tipo (e accessibilità)

guardiamo i nomi

e senza dubbio,

NetworkPacket potrebbe essere

• MultiCmdQueueCallback::NetworkPacket
• o PlcMsgFactoryImplCallback::NetworkPacket

Il fatto che entrambi indicano Networking::NetworkPacketè irrilevante.

Facciamo la risoluzione del nome, che si traduce in ambiguità.

Puoi semplicemente risolvere l'ambiguità selezionando manualmente quale vuoi usare.

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

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

}

Il compilatore cerca solo le definizioni nelle classi base. Se lo stesso tipo e / o alias è presente in entrambe le classi di base, si lamenta semplicemente di non sapere quale usare. Non importa se il tipo risultante è uguale o no.

Il compilatore cerca solo i nomi nel primo passaggio, completamente indipendente se questo nome è una funzione, un tipo, un alias, un metodo o altro. Se i nomi sono ambigui, non viene eseguita alcuna ulteriore azione dal compilatore! Si lamenta semplicemente con il messaggio di errore e si ferma. Quindi, risolvi semplicemente l'ambiguità con l'istruzione using fornita.

Dai documenti :

Una dichiarazione di tipo alias introduce un nome che può essere utilizzato come sinonimo del tipo indicato da id-tipo. Non introduce un nuovo tipo e non può cambiare il significato di un nome di tipo esistente.

Sebbene, queste due usingclausole rappresentino lo stesso tipo, il compilatore ha due scelte nella seguente situazione:

void sendNetworkPacket(const NetworkPacket &pdu);

Può scegliere tra:

• MultiCmdQueueCallback::NetworkPacket e
• PlcMsgFactoryImplCallback::NetworkPacket

perché eredita da entrambe MultiCmdQueueCallbacke PlcMsgFactoryImplCallbackclassi di base. Un risultato della risoluzione dei nomi del compilatore è l'errore di ambiguità che hai. Per risolvere questo problema, devi indicare esplicitamente al compilatore di utilizzare l'uno o l'altro come questo:

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

o

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

Ci sono due errori:

1. Accesso ad alias di tipo privato
2. Riferimento ambiguo alias di tipo

privato-privato

Non vedo un problema che il compilatore si lamenta prima del secondo problema perché l'ordine non ha molta importanza: per risolvere è necessario risolvere entrambi i problemi.

pubblico-pubblico

Se si modifica la visibilità di entrambi MultiCmdQueueCallback::NetworkPackete PlcMsgFactoryImplCallback::NetworkPacketsu pubblica o protetta, il secondo problema (ambiguità) è ovvio: si tratta di due alias di tipo diverso sebbene abbiano lo stesso tipo di dati sottostante. Alcuni potrebbero pensare che un compilatore "intelligente" possa risolvere questo (un caso specifico) per te, ma tieni presente che il compilatore deve "pensare in generale" e prendere decisioni basate su regole globali invece di fare eccezioni specifiche del caso. Immagina il seguente caso:

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


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

Il compilatore dovrebbe trattare entrambi NetworkPacketIDallo stesso modo? Sicuramente no. Perché su un sistema a 32 bit, size_tè lungo a 32 bit mentre uint64_tè sempre a 64 bit. Ma se vogliamo che il compilatore controlli i tipi di dati sottostanti, non potrebbe distinguerli su un sistema a 64 bit.

pubblico privato

Credo che questo esempio non abbia alcun senso nel caso d'uso di OP, ma dato che qui stiamo risolvendo problemi in generale, consideriamo che:

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

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

Penso che in questo caso il compilatore dovrebbe trattare PlcNetwork::NetworkPacketcome PlcMsgFactoryImplCallback::NetworkPacketperché non ha altre scelte. Perché rifiuta ancora di farlo e incolpa l'ambiguità per me è un mistero.