Tengo dos clases base con cláusulas de uso

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


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

Entonces declaro una clase

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

el compilador marca una referencia de error a 'NetworkPacket' es ambiguo 'sendNetworkPacket (NetworkPacket & ...'

Ahora ambas 'cláusulas de uso' se resuelven en la misma clase subyacente Redes: NetworkPacket

y de hecho si reemplazo la declaración del método con:

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

Se compila bien.

¿Por qué el compilador trata cada cláusula de uso como un tipo distinto a pesar de que ambos apuntan al mismo tipo subyacente? ¿Es obligatorio por el estándar o tenemos un error de compilación?

Antes de ver el tipo de alias resultante, (y accesibilidad)

nos fijamos en los nombres

y de hecho,

NetworkPacket puede ser

• MultiCmdQueueCallback::NetworkPacket
• o PlcMsgFactoryImplCallback::NetworkPacket

El hecho de que ambos apuntan Networking::NetworkPacketes irrelevante.

Hacemos la resolución del primer nombre, lo que resulta en ambigüedad.

Simplemente puede resolver la ambigüedad seleccionando manualmente cuál desea usar.

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

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

}

El compilador solo busca las definiciones en las clases base. Si el mismo tipo y / o alias está presente en ambas clases base, simplemente se queja de que no sabe cuál usar. No importa si el tipo resultante es el mismo o no.

El compilador solo busca nombres en el primer paso, totalmente independientes si este nombre es una función, tipo, alias, método o lo que sea. Si los nombres son ambiguos, ¡no se realiza ninguna otra acción desde el compilador! Simplemente se queja con el mensaje de error y se detiene. Entonces, simplemente resuelva la ambigüedad con la declaración de uso dada.

De los documentos :

Una declaración de alias de tipo introduce un nombre que se puede usar como sinónimo del tipo denotado por type-id. No introduce un nuevo tipo y no puede cambiar el significado de un nombre de tipo existente.

Aunque esas dos usingcláusulas representan el mismo tipo, el compilador tiene dos opciones en la siguiente situación:

void sendNetworkPacket(const NetworkPacket &pdu);

Puede elegir entre:

• MultiCmdQueueCallback::NetworkPacket y
• PlcMsgFactoryImplCallback::NetworkPacket

porque hereda de ambas MultiCmdQueueCallbacky de PlcMsgFactoryImplCallbacklas clases base. Un resultado de la resolución del nombre del compilador es el error de ambigüedad que tiene. Para solucionar esto, debe indicar explícitamente al compilador que use uno u otro de esta manera:

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

o

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

Hay dos errores:

1. Acceso a alias de tipo privado
2. Referencia ambigua a los alias de tipo

privado-privado

No veo un problema de que el compilador se queje del segundo problema primero porque el orden realmente no importa: debe solucionar ambos problemas para continuar.

público-público

Si cambia la visibilidad de ambos, MultiCmdQueueCallback::NetworkPacketya PlcMsgFactoryImplCallback::NetworkPacketsea ​​pública o protegida, entonces el segundo problema (ambigüedad) es obvio: esos son dos alias de tipo diferente, aunque tienen el mismo tipo de datos subyacente. Algunos pueden pensar que un compilador "inteligente" puede resolver esto (un caso específico) por usted, pero tenga en cuenta que el compilador necesita "pensar en general" y tomar decisiones basadas en reglas globales en lugar de hacer excepciones específicas de cada caso. Imagine el siguiente caso:

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


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

¿Debería el compilador tratar a ambos por NetworkPacketIDigual? Seguro que no. Porque en un sistema de 32 bits, size_ttiene 32 bits de largo mientras uint64_tque siempre es de 64 bits. Pero si queremos que el compilador verifique los tipos de datos subyacentes, entonces no podría distinguirlos en un sistema de 64 bits.

publico privado

Creo que este ejemplo no tiene ningún sentido en el caso de uso de OP, pero dado que aquí estamos resolviendo problemas en general, consideremos que:

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

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

Creo que en este caso el compilador debe tratar PlcNetwork::NetworkPacketcomo PlcMsgFactoryImplCallback::NetworkPacketporque no tiene otros Oferta de. Por qué todavía se niega a hacerlo y culpa a la ambigüedad es un misterio para mí.