【Solidity】继承

继承

Solidity 中使用 is 关键字实现继承：

contract Father {function getNumber() public pure returns (uint) {return 10;}function getNumber2() public pure virtual returns (uint) {return 20;}
}contract Son is Father {}

现在 Son 就可以调用 Father 的 getNumber、getNumber2 方法啦

函数重写

对于父合约中用 virtual 修饰的方法，可以在子合约中改用 override 修饰 并重写方法的内容：

contract Father {function getNumber() public pure returns (uint) {return 10;}function getNumber2() public pure virtual returns (uint) {return 20;}
}contract Son is Father {function getNumber2() public pure override returns (uint) {return 40;}
}

多级继承

contract Father {function getNumber() public pure returns (uint) {return 10;}function getNumber2() public pure virtual returns (uint) {return 20;}function getNumber3() public pure virtual returns (uint) {return 30;}
}contract Son is Father {function getNumber2() public pure override returns (uint) {return 40;}// 用 virtual 和 override 同时修饰方法function getNumber3() public pure virtual override returns (uint) {return 50;}
}contract GrandSon is Son {function getNumber3() public pure override returns (uint) {return 60;}
}

多重继承

在 Solidity 中，继承顺序通过 C3 线性化算法确定。这个算法确保继承关系是一个有向无环图（DAG），并强制一个特定的继承顺序。

demo1：

   X/ |
Y  |\ |Z

根据 C3 线性化算法，继承顺序是从最底层的合约开始，逐层向上合并继承路径。具体步骤如下：

1. 从最底层合约 Z 开始：

   • Z 继承自 Y 和 X。
   • 继承顺序：[Z, Y, X]。

2. 合并继承路径：

   • Y 继承自 X。
   • 继承顺序：[Y, X]。

3. 最终继承顺序：

   • 合并 Z 的继承顺序 [Z, Y, X] 和 Y 的继承顺序 [Y, X]。
   • 确保每个合约只出现一次，并且遵循继承关系。
   • 最终继承顺序为：[Z, Y, X]。

contract X {function foo() public virtual returns (string memory) {return "X";}
}contract Y is X {function foo() public virtual override returns (string memory) {return "Y";}
}// 根据继承顺序, 先 X 后 Y;  若遇平级, 则顺序随意
contract Z is X, Y {// override 里面的顺序无所谓function foo() public pure override(Y, X) returns (string memory) {return "Z";}
}

demo2：

  X/ \
Y   A
|   |
|   B\ /Z

根据 C3 线性化算法，继承顺序是从最底层的合约开始，逐层向上合并继承路径。具体步骤如下：

1. 从最底层合约 Z 开始：

   • Z 继承自 Y 和 B。
   • 继承顺序：[Z, Y, B]。

2. 合并继承路径：

   • Y 继承自 X。
   • B 继承自 A，A 继承自 X。
   • 继承顺序：[Y, X] 和 [B, A, X]。

3. 最终继承顺序：

   • 合并 Z 的继承顺序 [Z, Y, B] 和 Y 的继承顺序 [Y, X] 以及 B 的继承顺序 [B, A, X]。
   • 确保每个合约只出现一次，并且遵循继承关系。
   • 最终继承顺序为：[Z, Y, B, A, X]。

contract X {function foo() public virtual returns (string memory) {return "X";}
}contract Y is X {function foo() public virtual override returns (string memory) {return "Y";}
}contract A is X {function foo() public virtual override returns (string memory) {return "A";}
}contract B is A {function foo() public virtual override returns (string memory) {return "B";}
}contract Z is Y, B {function foo() public pure override(Y, B) returns (string memory) {return "Z";}
}

调用父合约的构造函数

contract A {string public name;constructor(string memory _name) {name = _name;}
}contract B {uint public number;constructor(uint _number) {number = _number;}
}// demo 1 - 在构造函数后面调用基类构造函数
contract C is A, B {constructor(string memory _name, uint _number) A(_name) B(_number) {}
}// demo 2 - 在合约定义时调用基类构造函数
contract D is A("Hello"), B(42) {}// demo 3 - 混合使用 demo 1 和 2 的方法
contract E is A("Hello"), B {constructor(uint _number) B(_number) {}
}

构造函数的调用顺序：先继承的父合约 → 后继承的父合约 → 当前合约

所以，demo 1 是 A → B → C、 demo 2 是 A → B → D、 demo 3 是 A → B → E

调用父合约的方法

contract A {event Log(string message);function func() public virtual {emit Log("A.func");}
}contract B is A {function func() public virtual override {emit Log("B.func");// 方法 1 - 通过 super 调用super.func(); // A}
}contract C is A {function func() public virtual override {emit Log("C.func");// 方法 2 - 通过合约调用A.func(); // A}
}contract D is B, C {// 方法 1 和方法 2 的区别function func() public override(B, C) {C.func(); // C - AB.func(); // B - AA.func(); // A}function funcD() public {super.func(); // C - B - A}
}