Was ist die Ausführungsreihenfolge von geerbten Konstruktoren in Solidity?

Ich konnte kein offizielles Dokument finden, um dies zu erklären. Aber wenn wir uns auf den Code, den Ablauf des Programms beziehen, können wir davon ausgehen, dass der Konstruktor von Basevor dem DerivedKonstruktor aufgerufen wird.

In der ersten sieht Derived1 is Base(7)die Base(7)Syntax wie der Konstruktor aus, wobei der Wert 7übergeben wird und wahrscheinlich aufgerufen wird, bevor der Derived1Konstruktor aufgerufen wird, wenn die deklarierte Reihenfolge berücksichtigt wird.

In der zweiten, da die Dokumente sagen,

die Art und Weise, wie ein Modifikator aufgerufen würde

und da immer die Modifikatoren ausgeführt werden, bevor wir in den Funktionskörper gehen, können wir zu dem Schluss kommen, dass Base(7)zuerst ausgeführt wird.

Mit den obigen Annahmen habe ich den folgenden Code in Remix mit _y=10bei der Vertragserstellung ausprobiert. Die getXFunktion in beiden Verträgen hat einen Wert von zurückgegeben 10, aber nicht 7in Derived1oder 100was (_y*_y)in ist Derived2. Das bedeutet, dass Baseder Konstruktor zuerst ausgeführt wird und der Wert von im Körper der Konstruktoren durch xüberschrieben wird. Ich denke, dies beweist, dass der Konstruktor zuerst erwartet wird.10x = _y;DerivedBase

pragma solidity ^0.4.0;

contract Base {
  uint x;
  function Base(uint _x) { x = _x; }
}


contract Derived1 is Base(7) {
  function Derived1(uint _y) {
      x = _y;
  }

  function getX() constant returns(uint){
      return x;
  }
}

contract Derived2 is Base {
  function Derived2(uint _y) Base(_y * _y) {
      x = _y;
  }

  function getX() constant returns(uint){
      return x;
  }

}

x = _y(Wenn Sie in Konstruktoren keine Derivedzurückgegebenen Werte haben, sind 7und 100)

Aktuelle Solidity-Dokumente liefern die Antwort in diesem Absatz: https://docs.soliditylang.org/en/v0.8.13/contracts.html#multiple-inheritance-and-linearization

Grundsätzlich gilt: Solidity garantiert, dass alle Konstruktoren der Basisklassen vor einem Konstruktor einer abgeleiteten Klasse aufgerufen werden. Und der Konstruktor der abgeleiteten Klasse kann die Reihenfolge, in der Konstruktoren der Basisklassen von Solidity aufgerufen werden, nicht ändern.

Dies ist jedoch etwas kompliziert, da Solidity mit Mehrfachvererbung umgehen muss. Wie in der Dokumentation erläutert, wird der Vererbungsgraph für die abgeleitete Klasse mit C3-Linearisierung linearisiert , was eine geordnete Liste von Klassen ergibt, in der jede abgeleitete Klasse nach all ihren Basisklassen erscheint. Die Konstruktoren werden in der Reihenfolge der Liste aufgerufen. Wenn Sie mehr als eine Basisklasse haben, wird die Reihenfolge, in der sie in der Liste erscheinen, von der Reihenfolge beeinflusst, in der sie in der Vererbungsliste aufgeführt sind (dh nach dem is).

Zitat aus der Dokumentation:

Ein Bereich, in dem die Vererbungslinearisierung besonders wichtig und vielleicht nicht so klar ist, ist, wenn es mehrere Konstruktoren in der Vererbungshierarchie gibt. Die Konstruktoren werden immer in der linearisierten Reihenfolge ausgeführt, unabhängig von der Reihenfolge, in der ihre Argumente im Konstruktor des erbenden Vertrags bereitgestellt werden. Zum Beispiel:

// SPDX-License-Identifier: GPL-3.0
pragma solidity >=0.7.0 <0.9.0;

contract Base1 {
    constructor() {}
}

contract Base2 {
    constructor() {}
}

// Constructors are executed in the following order:
//  1 - Base1
//  2 - Base2
//  3 - Derived1
contract Derived1 is Base1, Base2 {
    constructor() Base1() Base2() {}
}

// Constructors are executed in the following order:
//  1 - Base2
//  2 - Base1
//  3 - Derived2
contract Derived2 is Base2, Base1 {
    constructor() Base2() Base1() {}
}

// Constructors are still executed in the following order:
//  1 - Base2
//  2 - Base1
//  3 - Derived3
contract Derived3 is Base2, Base1 {
    constructor() Base1() Base2() {}
}