Solidity：合约继承

孟斯特

发布于 2024-05-28 20:40:31

980

发布于 2024-05-28 20:40:31

文章被收录于专栏：code人生code人生

在Solidity中，继承是一种使一个合约可以获取另一个合约的属性和方法的方式。这是一种代码复用的方法，可以使你的代码更加模块化，更易于理解和维护。

在Solidity中，一个合约可以继承多个合约，这些被继承的合约被称为父合约或基础合约。继承的语法是在子合约的定义后面使用is关键字，然后列出所有的父合约。

以下是一个简单的示例：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

contract A {
    function foo() public pure returns (string memory) {
        return "foo";
    }
}

contract B is A {
}

在这个示例中，合约B继承了合约A。这意味着B合约可以访问A合约的所有公有和内部函数。例如，你可以在B合约中调用foo函数，就像它是B合约的一部分一样。

如果一个合约继承了多个合约，那么这些合约的函数和状态变量都会被包含在子合约中。如果多个父合约有相同的函数或状态变量，那么会按照在子合约中列出的顺序来解决冲突，后面列出的合约会覆盖前面的合约。

需要注意的是，父合约的构造函数不会自动被调用，你需要在子合约的构造函数中显式地调用它们。此外，父合约的函数可以被子合约重写，但是需要使用override关键字。

总的来说，Solidity中的继承是一种强大的功能，它可以帮助你创建更复杂的合约，同时保持代码的模块化和可维护性。

constructor函数可以被继承吗？

在Solidity中，constructor函数是一个特殊的函数，它在合约被部署到区块链时自动执行。这个函数在合约的生命周期中只会被调用一次，就是在合约创建时。一旦constructor函数被调用并且合约被成功部署到区块链上，constructor函数就不能再被调用了。

当一个合约从另一个合约继承时，父合约的constructor函数不会自动被子合约继承。相反，子合约需要在其constructor函数中显式调用父合约的constructor函数。这是通过在子合约的constructor函数中使用父合约的名称和所需参数来完成的。

以下是一个示例：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.25;

contract Parent {
    uint public x;

    constructor(uint _x) {
        x = _x;
    }
}

contract Child is Parent {
    constructor(uint _x) Parent(_x) {
    }
}

在这个示例中，Child合约从Parent合约继承。Parent合约有一个constructor函数，它接受一个参数_x并将其值赋给状态变量x。Child合约也有一个constructor函数，它通过Parent(_x)调用父合约的constructor函数。

当Child合约被部署到区块链上时，首先会调用Parent合约的constructor函数，然后才会调用Child合约的constructor函数。这意味着x的值会被设置为_x，就像在Parent合约中一样。

虽然不能在子合约中重写父合约的constructor函数，但是父合约的constructor函数会在子合约创建时自动被调用。

在Solidity中，如果一个合约继承了多个父合约，那么每个父合约的constructor函数都会被调用一次。这些调用是在子合约的constructor函数中显式进行的。

当你部署一个子合约时，Solidity会按照在子合约中列出父合约的顺序来调用这些constructor函数。首先调用的是最先列出的父合约的constructor函数，然后是第二个，依此类推，直到所有的父合约的constructor函数都被调用。

super

在Solidity中，super关键字是一个特殊的引用，它用于访问被当前合约重写的函数。当你在一个函数中使用super关键字时，Solidity会查找继承链中的下一个实现。

在Solidity中，super关键字的调用顺序是由C3线性化算法确定的。这是一个在Python中用于解决多重继承问题的算法，Solidity也采用了这个算法来确定合约的继承顺序。

在使用super关键字时，Solidity会按照C3线性化算法确定的顺序来调用函数。这个顺序是由合约的继承列表决定的。在继承列表中，最后列出的合约最先被调用，然后是倒数第二个，依此类推，直到所有的合约都被调用。

以下是一个示例：

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;

contract A {
    function foo() public pure returns (string memory) {
        return "A";
    }
}

contract B is A {
    function foo() public pure override returns (string memory) {
        return "B";
    }
}

contract C is A {
    function foo() public pure override returns (string memory) {
        return "C";
    }
}

contract D is B, C {
    function foo() public pure override(B, C) returns (string memory) {
        return super.foo();
    }
}

在这个示例中，合约D继承了合约B和C，并且重写了foo函数。在D合约的foo函数中，我们使用super关键字调用了foo函数。由于super关键字的存在，这将首先调用C合约的foo函数（因为在D合约中，C是最后一个列出的父合约），然后是B合约的foo函数，最后是A合约的foo函数。

总的来说，super关键字在Solidity中是一个强大的工具，它允许你在重写函数的同时，仍然可以访问被重写函数的原始实现。super关键字的调用顺序是由C3线性化算法确定的，这个顺序是由合约的继承列表决定的。

扩展：C3线性化算法

C3线性化算法是一种用于确定类的方法解析顺序（MRO）的算法。它最初是为Python的类继承设计的，但也被其他语言，如Perl和Solidity，所采用。

C3线性化算法的主要目标是提供一种一致且明确的类继承顺序，同时尽可能地保留类的声明顺序。这意味着如果类B继承自类A，那么在任何情况下，类A都应该在类B之前。

C3线性化算法的工作原理如下：

1.首先，如果一个类没有任何父类（除了object类），那么它的MRO就是它自己。2.如果一个类有一个父类，那么它的MRO就是它自己，后面跟着它的父类的MRO。3.如果一个类有多个父类，那么它的MRO就是它自己，后面跟着每个父类的MRO，这些父类的MRO是按照它们在类定义中的顺序合并的。

这个算法的一个关键特性是它能够处理复杂的继承图，并且能够产生一致的结果，即使在存在菱形继承（一个类有两个父类，这两个父类又有一个共同的父类）的情况下也是如此。

在Solidity中，C3线性化算法用于确定合约的继承顺序，这对于理解super关键字的行为非常重要。

声明：本作品采用署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0)[1]进行许可，使用时请注明出处。 Author: mengbin[2] blog: mengbin[3] Github: mengbin92[4] cnblogs: 恋水无意[5] 腾讯云开发者社区：孟斯特[6]

References

[1] 署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0): https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh [2] mengbin: mengbin1992@outlook.com [3] mengbin: https://mengbin.top [4] mengbin92: https://mengbin92.github.io/ [5] 恋水无意: https://www.cnblogs.com/lianshuiwuyi/ [6] 孟斯特: https://cloud.tencent.com/developer/user/6649301