Ich habe zwei Basisklassen mit using-Klauseln

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


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

Ich erkläre dann eine Klasse

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

Der Compiler kennzeichnet dann einen Fehlerverweis auf 'NetworkPacket', der nicht eindeutig ist. 'sendNetworkPacket (NetworkPacket & ...'

Jetzt werden beide 'using-Klauseln' in dieselbe zugrunde liegende Klasse Networking: NetworkPacket aufgelöst

und in der Tat, wenn ich die Methodendeklaration durch Folgendes ersetze:

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

es kompiliert gut.

Warum behandelt der Compiler jede using-Klausel als einen eigenen Typ, obwohl beide auf denselben zugrunde liegenden Typ verweisen? Ist dies vom Standard vorgeschrieben oder haben wir einen Compiler-Fehler?

Bevor Sie sich den resultierenden Alias-Typ (und die Barrierefreiheit) ansehen

Wir schauen uns Namen an

und in der Tat,

NetworkPacket könnte sein

• MultiCmdQueueCallback::NetworkPacket
• oder PlcMsgFactoryImplCallback::NetworkPacket

Die Tatsache, auf die beide hinweisen, Networking::NetworkPacketist irrelevant.

Wir führen die Auflösung von Vornamen durch, was zu Mehrdeutigkeiten führt.

Sie können die Mehrdeutigkeit einfach beheben, indem Sie manuell auswählen, welche Sie verwenden möchten.

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

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

}

Der Compiler sucht nur nach den Definitionen in den Basisklassen. Wenn in beiden Basisklassen der gleiche Typ und / oder Alias ​​vorhanden ist, wird lediglich beanstandet, dass nicht bekannt ist, welcher Typ verwendet werden soll. Es spielt keine Rolle, ob der resultierende Typ der gleiche ist oder nicht.

Der Compiler sucht nur im ersten Schritt nach Namen, völlig unabhängig, ob dieser Name eine Funktion, ein Typ, ein Alias, eine Methode oder was auch immer ist. Wenn die Namen nicht eindeutig sind, wird vom Compiler keine weitere Aktion ausgeführt! Es beschwert sich einfach mit der Fehlermeldung und stoppt. Lösen Sie also einfach die Mehrdeutigkeit mit der angegebenen using-Anweisung.

Aus den Dokumenten :

Eine Typ-Alias-Deklaration führt einen Namen ein, der als Synonym für den mit Typ-ID bezeichneten Typ verwendet werden kann. Es wird kein neuer Typ eingeführt und die Bedeutung eines vorhandenen Typnamens kann nicht geändert werden.

Obwohl diese beiden usingKlauseln denselben Typ darstellen, hat der Compiler in der folgenden Situation zwei Möglichkeiten:

void sendNetworkPacket(const NetworkPacket &pdu);

Es kann wählen zwischen:

• MultiCmdQueueCallback::NetworkPacket und
• PlcMsgFactoryImplCallback::NetworkPacket

weil es von beiden MultiCmdQueueCallbackund PlcMsgFactoryImplCallbackBasisklassen erbt . Ein Ergebnis der Namensauflösung des Compilers ist ein Mehrdeutigkeitsfehler, den Sie haben. Um dies zu beheben, müssen Sie den Compiler explizit anweisen, das eine oder andere wie folgt zu verwenden:

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

oder

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

Es gibt zwei Fehler:

1. Zugriff auf Aliase vom Typ Private
2. Mehrdeutiger Verweis auf Typ-Aliase

privat-privat

Ich sehe kein Problem, dass sich der Compiler zuerst über das zweite Problem beschwert, da die Reihenfolge nicht wirklich wichtig ist - Sie müssen beide Probleme beheben, um fortzufahren.

öffentlich-öffentlich

Wenn Sie die Sichtbarkeit von beiden ändern MultiCmdQueueCallback::NetworkPacketund PlcMsgFactoryImplCallback::NetworkPacketentweder öffentlich oder geschützt, ist das zweite Problem (Mehrdeutigkeit) offensichtlich - dies sind zwei verschiedene Typ-Aliase, obwohl sie denselben zugrunde liegenden Datentyp haben. Einige mögen denken, dass ein "kluger" Compiler dies (einen bestimmten Fall) für Sie lösen kann, aber denken Sie daran, dass der Compiler "allgemein denken" und Entscheidungen auf der Grundlage globaler Regeln treffen muss, anstatt fallspezifische Ausnahmen zu treffen. Stellen Sie sich folgenden Fall vor:

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


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

Sollte der Compiler beide NetworkPacketIDgleich behandeln? Sicher nicht. Denn auf einem 32-Bit-System size_tist es 32-Bit lang, während uint64_tes immer 64-Bit ist. Wenn der Compiler jedoch nach zugrunde liegenden Datentypen suchen soll, kann er diese auf einem 64-Bit-System nicht unterscheiden.

öffentlich-privat

Ich glaube, dieses Beispiel macht im Anwendungsfall von OP keinen Sinn, aber da wir hier allgemein Probleme lösen, betrachten wir Folgendes:

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

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

Ich denke in diesem Fall sollte der Compiler so behandeln, PlcNetwork::NetworkPacketals hätte PlcMsgFactoryImplCallback::NetworkPacketer keine anderen Möglichkeiten. Warum es sich immer noch weigert und die Mehrdeutigkeit beschuldigt, ist mir ein Rätsel.