J'ai deux classes de base avec des clauses using

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


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

Je déclare ensuite une classe

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

le compilateur signale ensuite une référence d'erreur à 'NetworkPacket' est ambigu 'sendNetworkPacket (NetworkPacket & ...'

Désormais, les deux «clauses d'utilisation» se résolvent dans la même classe sous-jacente. Networking: NetworkPacket

et en fait si je remplace la déclaration de méthode par:

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

il compile très bien.

Pourquoi le compilateur traite-t-il chaque clause using comme un type distinct, même si elles pointent toutes les deux vers le même type sous-jacent? Est-ce obligatoire par la norme ou avons-nous un bug de compilation?

Avant d'examiner le type résultant d'alias (et l'accessibilité)

on regarde les noms

et en effet,

NetworkPacket pourrait être

• MultiCmdQueueCallback::NetworkPacket
• ou PlcMsgFactoryImplCallback::NetworkPacket

Le fait qu'ils indiquent tous les deux Networking::NetworkPacketest sans importance.

Nous effectuons la résolution des prénoms, ce qui entraîne une ambiguïté.

Vous pouvez simplement résoudre l'ambiguïté en sélectionnant manuellement celle que vous souhaitez utiliser.

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

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

}

Le compilateur recherche uniquement les définitions dans les classes de base. Si le même type et / ou alias est présent dans les deux classes de base, il se plaint simplement de ne pas savoir lequel utiliser. Peu importe que le type résultant soit le même ou non.

Le compilateur recherche uniquement les noms à la première étape, totalement indépendant si ce nom est une fonction, un type, un alias, une méthode ou autre. Si les noms sont ambigus, aucune autre action n'est effectuée à partir du compilateur! Il se plaint simplement du message d'erreur et s'arrête. Il suffit donc de résoudre l'ambiguïté avec l'instruction using donnée.

De la documentation :

Une déclaration d'alias de type introduit un nom qui peut être utilisé comme synonyme du type dénoté par type-id. Il n'introduit pas de nouveau type et ne peut pas changer la signification d'un nom de type existant.

Bien que ces deux usingclauses représentent le même type, le compilateur a deux choix dans la situation suivante:

void sendNetworkPacket(const NetworkPacket &pdu);

Il peut choisir entre:

• MultiCmdQueueCallback::NetworkPacket et
• PlcMsgFactoryImplCallback::NetworkPacket

car il hérite des deux classes MultiCmdQueueCallbacket des PlcMsgFactoryImplCallbackclasses de base. Un résultat de la résolution du nom du compilateur est une erreur d'ambiguïté que vous avez. Pour résoudre ce problème, vous devez explicitement demander au compilateur d'utiliser l'un ou l'autre comme ceci:

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

ou

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

Il y a deux erreurs:

1. Accès aux alias de type privé
2. Référence ambiguë aux types d'alias

privé-privé

Je ne vois pas de problème que le compilateur se plaint d'abord du deuxième problème parce que l'ordre n'a pas vraiment d'importance - vous devez résoudre les deux problèmes pour continuer.

public-public

Si vous modifiez la visibilité des deux MultiCmdQueueCallback::NetworkPacketet PlcMsgFactoryImplCallback::NetworkPacketen public ou protégé, le deuxième problème (ambiguïté) est évident - ce sont deux alias de type différents bien qu'ils aient le même type de données sous-jacent. Certains peuvent penser qu'un compilateur "intelligent" peut résoudre cela (un cas spécifique) pour vous, mais gardez à l'esprit que le compilateur doit "penser en général" et prendre des décisions basées sur des règles globales au lieu de faire des exceptions spécifiques à la casse. Imaginez le cas suivant:

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


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

Le compilateur doit-il traiter les deux de NetworkPacketIDla même façon? Bien sûr que non. Parce que sur un système 32 bits, size_test 32 bits de long toutuint64_t est toujours de 64 bits. Mais si nous voulons que le compilateur vérifie les types de données sous-jacents, il ne peut pas distinguer ceux sur un système 64 bits.

public-privé

Je crois que cet exemple n'a aucun sens dans le cas d'utilisation d'OP, mais puisque nous résolvons ici des problèmes en général, considérons que:

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

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

Je pense que dans ce cas, le compilateur doit traiter PlcNetwork::NetworkPacketcomme PlcMsgFactoryImplCallback::NetworkPacketparce qu'il n'a pas d'autre choix. Pourquoi il refuse toujours de le faire et blâme l'ambiguïté est un mystère pour moi.