pragma solidity ^0.4.16;

contract C {
    function f(uint a, uint b) pure returns (uint) {
        return a * (b + 42);
    }
}

编译器并没有强制执行纯粹的方法不是从状态中读取的。

后备函数

合约可以有一个未命名的功能。 这个函数不能有参数，不能返回任何东西。 如果没有其他功能与给定的功能标识符（或者根本没有提供任何数据）匹配，则在对合约的调用中执行。

此外，只要合约收到普通的Ether（无数据），就执行此功能。 在这种情况下，函数调用通常只有很少的气体（精确的是2300个gas），所以重要的是使后备功能尽可能的便宜。

特别是，以下操作将比提供给回退功能的津贴消耗更多的气体：

请确保您彻底测试您的后备功能，以确保执行成本低于2300gas，然后再部署合同。

直接接收Ether（即不使用函数调用，即使用发送或传输）但不定义回退函数的合约引发异常，发回Ether（在Solidity v0.4.0之前不同）。 因此，如果您希望您的合同获得Ether，您必须实施一个备用功能。

pragma solidity ^0.4.0;

contract Test {
    // 对于发送到此合同的所有邮件（没有其他功能），将调用此函数。
    // 将Ether发送到此合约将导致异常，因为fallback函数没有“payable”修饰符。
    function() { x = 1; }
    uint x;
}


// 这个合同让所有的Ether发送给它，没有办法让它回来。
contract Sink {
    function() payable { }
}


contract Caller {
    function callTest(Test test) {
        test.call(0xabcdef01); // 哈希不存在
        // 导致test.x成为== 1。

        // 以下将不会编译，但即使有人向该合约发送了Ether，该事务将失败并拒绝Ether。
        //test.send(2 ether);
    }
}

事件

事件允许方便地使用EVM记录工具，这又可以用来“调用”dapp的用户界面中的JavaScript回调，该回调监听这些事件。

事件是合同的继承成员。 当它们被调用时，它们使参数存储在事务的日志中 - 块链中的特殊数据结构。 这些日志与合同的地址相关联，并且将被并入块链，只要块可以访问（永远是Frontier和Homestead，但是这可能会随着宁静而改变）。 日志和事件数据无法从合同中获取（甚至不是从创建它们的合同）。

日志的SPV证明是可能的，所以如果一个外部实体向合同提供了这样的证明，它可以检查该日志是否存在于该块内。 但是请注意，必须提供块头，因为合约只能看到最后256个块的哈希值。

最多三个参数可以接收索引的属性，这将导致搜索相应的参数：可以在用户界面中过滤索引参数的特定值。

如果使用数组（包括字符串和字节）作为索引参数，则将其Keccak-256哈希存储为主题。

除了使用匿名说明符声明事件之外，事件签名的散列是其中一个主题。 这意味着不可能按名称过滤特定的匿名事件。

所有非索引的参数都将存储在日志的数据部分。

索引参数不会自己存储。 您只能搜索值，但不可能自己检索值。

pragma solidity ^0.4.0;

contract ClientReceipt {
    event Deposit(
        address indexed _from,
        bytes32 indexed _id,
        uint _value
    );

    function deposit(bytes32 _id) payable {
        // 任何调用这个函数（甚至是深嵌套的）都可以从JavaScript API中通过过滤`Deposit`来调用。
        Deposit(msg.sender, _id, msg.value);
    }
}

JavaScript API中的用法如下：

var abi = /* abi由编译器生成*/;
var ClientReceipt = web3.eth.contract(abi);
var clientReceipt = ClientReceipt.at("0x1234...ab67" /* 地址 */);

var event = clientReceipt.Deposit();

// 监视更改
event.watch(function(error, result){
    // 结果将包含各种信息，包括给予Deposit调用的参数。
    if (!error)
        console.log(result);
});

// 或者通过回调立即开始观看
var event = clientReceipt.Deposit(function(error, result) {
    if (!error)
        console.log(result);
});

低层次的接口日志

还可以通过函数log0，log1，log2，log3和log4访问记录机制的低级接口。 logi采用类型为byte32的i + 1参数，其中第一个参数将用于日志的数据部分，而其他参数用作主题。 上述事件调用可以以相同的方式执行

log3(
    msg.value,
    0x50cb9fe53daa9737b786ab3646f04d0150dc50ef4e75f59509d83667ad5adb20,
    msg.sender,
    _id
)

其中长十六进制数等于keccak256("Deposit(address,hash256,uint256)") ，事件的签名。

了解事件的其他资源

- 如何在js中访问它们

遗产

Solidity通过复制代码（包括多态）来支持多重继承。

所有函数调用都是虚拟的，这意味着调用最多的派生函数，除非明确地给出了合同名称。

当合同从多个合同继承时，在块链上只创建一个合同，并将所有基础合同的代码复制到创建的合同中。

一般继承系统与Python非常相似，特别是关于多重继承。

以下示例给出了详细信息。

pragma solidity ^0.4.0;

contract owned {
    function owned() { owner = msg.sender; }
    address owner;
}


// 使用is来自另一个合约.派生合同可以访问所有非私人成员，包括内部函数和状态变量。 这些不能通过`this`从外部访问。
contract mortal is owned {  //派生
    function kill() {
        if (msg.sender == owner) selfdestruct(owner);
    }
}


// 仅提供这些抽象契约以使编译器已知接口。 注意没有body的函数。 如果一个合约没有实现所有的功能，它只能用作一个接口。
contract Config {
    function lookup(uint id) returns (address adr);
}


contract NameReg {
    function register(bytes32 name);
    function unregister();
 }


// 多重继承是可能的。 注意，“拥有”也是“凡人”的基类，但只有一个“拥有”的实例（对于C ++中的虚拟继承）。
contract named is owned, mortal {
    function named(bytes32 name) {
        Config config = Config(0xd5f9d8d94886e70b06e474c3fb14fd43e2f23970);
        NameReg(config.lookup(1)).register(name);
    }

    // 函数可以由具有相同名称和相同数量/类型的输入的另一个功能覆盖。 如果覆盖函数具有不同类型的输出参数，则会导致错误。 本地和基于消息的函数调用都考虑到这些覆盖。
    function kill() {
        if (msg.sender == owner) {
            Config config = Config(0xd5f9d8d94886e70b06e474c3fb14fd43e2f23970);
            NameReg(config.lookup(1)).unregister();
            // 仍然可以调用特定的重写函数。
            mortal.kill();
        }
    }
}


// 如果一个构造函数接受一个参数，则需要在标题中提供（或者在派生契约的构造函数中使用修饰符调用风格）（见下文））。
contract PriceFeed is owned, mortal, named("GoldFeed") {
   function updateInfo(uint newInfo) {
      if (msg.sender == owner) info = newInfo;
   }

   function get() constant returns(uint r) { return info; }

   uint info;
}

请注意，我们称之为mortal.kill()来“转发”销毁请求。 这样做是有问题的，如以下示例所示：

pragma solidity ^0.4.0;

contract owned {
    function owned() { owner = msg.sender; }
    address owner;
}

contract mortal is owned {
    function kill() {
        if (msg.sender == owner) selfdestruct(owner);
    }
}

contract Base1 is mortal {
    function kill() { /* do cleanup 1 */ mortal.kill(); }
}


contract Base2 is mortal {
    function kill() { /* do cleanup 2 */ mortal.kill(); }
}


contract Final is Base1, Base2 {
}

对Final.kill()的调用将调用Base2.kill作为最常用的替代方法，但这个函数将绕过Base1.kill，这主要是因为它甚至不了解Base1。 这样做的方法是使用super：

pragma solidity ^0.4.0;

contract owned {
    function owned() { owner = msg.sender; }
    address owner;
}

contract mortal is owned {
    function kill() {
        if (msg.sender == owner) selfdestruct(owner);
    }
}


contract Base1 is mortal {
    function kill() { /* do cleanup 1 */ super.kill(); }
}


contract Base2 is mortal {
    function kill() { /* do cleanup 2 */ super.kill(); }
}


contract Final is Base2, Base1 {
}

如果Base1调用super函数，它不会简单地在其基础合约之一调用此函数。 相反，它将这个函数称为最终继承图中的下一个基本合约，因此它将调用Base2.kill()（注意，最后的继承序列是 - 从最为导出的合约开始：Final，Base1，Base2，owned）。 使用super时调用的实际函数在使用它的类的上下文中是未知的，尽管它的类型是已知的。 这对于普通虚拟方法查找是类似的。

基础构造函数的参数

派生合约需要提供基础构造函数所需的所有参数。 这可以通过两种方式完成：

pragma solidity ^0.4.0;

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


contract Derived is Base(7) {
    function Derived(uint _y) Base(_y * _y) {
    }
}

一种方法是直接在继承列表（Base（7））。 另一个方法是将一个修饰符作为派生构造函数（Base（_y * _y））的头部的一部分被调用。 如果构造函数参数是一个常量，并定义了合同的行为或者描述了它的行为，那么第一种做法更为方便。 如果基础的构造函数参数取决于派生合同的参数，则必须使用第二种方法。 如果在这个愚蠢的例子中使用了两个地方，那么修饰符样式的参数就是优先级。

多重继承和线性化

允许多重继承的语言必须处理几个问题。 一个是[钻石问题]https://en.wikipedia.org/wiki/Multiple_inheritance)。 Solidity遵循Python的路径，并使用“C3线性化”来强制基类的DAG中的特定顺序。 这导致单调性的理想属性，但不允许一些继承图。 特别地，在指令中给出基类的顺序很重要。 在下面的代码中，Solidity会给出“不可能的继承图的线性化”错误。

// 不会被编译

pragma solidity ^0.4.0;

contract X {}
contract A is X {}
contract C is A, X {}

原因是C请求X覆盖A（通过以此顺序指定A，X），但A本身请求覆盖X，这是无法解决的矛盾。

要记住的一个简单的规则是按照从“最基本像”到“最多派生”的顺序来指定基类。

继承的同名成员的不同类型

当继承导致与同名的函数和修饰符的合同时，它被认为是错误。 此错误也由相同名称的事件和修饰符以及相同名称的函数和事件生成。 作为例外，状态变量getter可以覆盖公共函数。

抽象合约

合约的函数可以缺少一个实现如下面的例子（注意，函数声明报头由终止;）：

pragma solidity ^0.4.0;

contract Feline {
    function utterance() returns (bytes32);
}

这种合同无法编译（即使它们包含已实现的功能以及未实现的功能），但可以作为基础合同使用：

pragma solidity ^0.4.0;

contract Feline {
    function utterance() returns (bytes32);
}

contract Cat is Feline {
    function utterance() returns (bytes32) { return "miaow"; }
}

如果合约从抽象合约中继承，并且通过重写实现所有未实现的所有函数，它本身就是抽象的。

接口

接口类似于抽象合同，但它们不能实现任何功能。 还有进一步的限制：

无法继承其他合同或接口。
无法定义构造函数。
无法定义变量。
无法定义结构体。
无法定义枚举。
其中一些限制可能会在未来取消。

接口基本上限于合同ABI可以表示的内容，ABI和接口之间的转换应该是可能的，没有任何信息丢失。

接口用自己的关键词表示：

pragma solidity ^0.4.11;

interface Token {
    function transfer(address recipient, uint amount);
}

合约可以继承接口，因为他们将继承其他合约。

库

库与合约类似，但其目的是在特定地址部署一次，并使用EVM的DELEGATECALL（CALLCODE until Homestead）功能重用其代码。 这意味着如果调用库函数，则它们的代码在呼叫契约的上下文中执行，即这指向呼叫合同，特别是可以访问来自呼叫合同的存储。 由于库是孤立的源代码，所以只有明确提供调用契约的状态变量才可以访问（否则就无法命名）。

库可以被看作是使用它们的合约隐含基类合约。 它们不会在继承层次结构中显式显示，但对库函数的调用就像调用显式基础合约的函数（L.f（），如果L是库的名称）。 此外，图书馆的内部功能在所有合同中都可见，就像图书馆是基本合同一样。 当然，对内部函数的调用使用内部调用约定，这意味着所有内部类型都可以传递，内存类型将被引用传递而不被复制。 为了在EVM中实现这一点，内部库函数的代码和从其中调用的所有函数将被拉入呼叫合约，并且将使用常规JUMP调用而不是DELEGATECALL。

以下示例说明了如何使用库（但请确保使用更高级的示例查看以实现集合）。

pragma solidity ^0.4.11;

library Set {
  // 我们定义一个新的结构数据类型，用于将其数据保存在调用合约中。
  struct Data { mapping(uint => bool) flags; }

  // 请注意，第一个参数类型为“存储引用”，因此只有其存储地址而不是其内容作为调用的一部分传递。 这是库函数的特殊功能。 调用第一个参数“self”是惯用的，如果该函数可以看作是该对象的一个方法。
  function insert(Data storage self, uint value)
      returns (bool)
  {
      if (self.flags[value])
          return false; // already there
      self.flags[value] = true;
      return true;
  }

  function remove(Data storage self, uint value)
      returns (bool)
  {
      if (!self.flags[value])
          return false; // not there
      self.flags[value] = false;
      return true;
  }

  function contains(Data storage self, uint value)
      returns (bool)
  {
      return self.flags[value];
  }
}


contract C {
    Set.Data knownValues;

    function register(uint value) {
        // 库函数可以在没有库的特定实例的情况下调用，因为“实例”将是当前的合约。
        require(Set.insert(knownValues, value));
    }
    // 在这个合约中，如果我们想要的话，我们也可以直接访问`knownValues.flags`。
}

当然，您不需要按照这种方式使用库 - 也可以在不定义struct数据类型的情况下使用它们。 函数也可以在没有任何存储参考参数的情况下工作，并且它们可以具有多个存储参考参数并处于任何位置

对Set.contains，Set.insert和Set.remove的调用都被编译为外部契约/库的调用（DELEGATECALL）。 如果使用库，请注意执行实际的外部函数调用。 msg.sender，msg.value，这将保留在此调用中的值，尽管（在Homestead之前，由于使用CALLCODE，msg.sender和msg.value已更改）。

以下示例显示了如何在库中使用内存类型和内部函数，以便实现自定义类型，而不需要外部函数调用的开销：

pragma solidity ^0.4.0;

library BigInt {
    struct bigint {
        uint[] limbs;
    }

    function fromUint(uint x) internal returns (bigint r) {
        r.limbs = new uint[](1);
        r.limbs[0] = x;
    }

    function add(bigint _a, bigint _b) internal returns (bigint r) {
        r.limbs = new uint[](max(_a.limbs.length, _b.limbs.length));
        uint carry = 0;
        for (uint i = 0; i < r.limbs.length; ++i) {
            uint a = limb(_a, i);
            uint b = limb(_b, i);
            r.limbs[i] = a + b + carry;
            if (a + b < a || (a + b == uint(-1) && carry > 0))
                carry = 1;
            else
                carry = 0;
        }
        if (carry > 0) {
            // too bad, we have to add a limb
            uint[] memory newLimbs = new uint[](r.limbs.length + 1);
            for (i = 0; i < r.limbs.length; ++i)
                newLimbs[i] = r.limbs[i];
            newLimbs[i] = carry;
            r.limbs = newLimbs;
        }
    }

    function limb(bigint _a, uint _limb) internal returns (uint) {
        return _limb < _a.limbs.length ? _a.limbs[_limb] : 0;
    }

    function max(uint a, uint b) private returns (uint) {
        return a > b ? a : b;
    }
}


contract C {
    using BigInt for BigInt.bigint;

    function f() {
        var x = BigInt.fromUint(7);
        var y = BigInt.fromUint(uint(-1));
        var z = x.add(y);
    }
}

由于编译器无法知道库将在哪里部署，这些地址必须通过链接器填充到最终的字节码（请参阅使用Commandline编译器了解如何使用命令行编译器进行链接）。 如果地址不作为参数提供给编译器编译后的十六进制代码将包含形式Set____（这里是集库的名称）的占位符。 可以通过使用图书馆契约地址的十六进制编码替换所有40个符号来手动填充地址。

在比较合约库限制：

（这些可能在稍后的时候被解除。）

using for

指令使用A为B; 可用于将库函数（从库A）附加到任何类型（B）。 这些函数将接收它们被调用的对象作为它们的第一个参数（如Python中的自变量）。

using A for *;的效果; 是从库A的功能附加到任何类型。

在这两种情况下，所有功能，即使那些第一个参数的类型与对象的类型不匹配的函数也被附加。 在调用该函数的时候检查该类型，并执行函数重载分辨率。

使用A为B; 指令对于当前的范围是活跃的，这个范围现在仅限于一个合同，但将在以后被提交到全球范围，因此通过包括一个模块，其数据类型包括库函数可用，而无需添加进一步的代码。

让我们以这种方式从库中重写集合示例：

pragma solidity ^0.4.11;

// 这是与以前一样的代码，只是没有注释
library Set {
  struct Data { mapping(uint => bool) flags; }

  function insert(Data storage self, uint value)
      returns (bool)
  {
      if (self.flags[value])
        return false; // already there
      self.flags[value] = true;
      return true;
  }

  function remove(Data storage self, uint value)
      returns (bool)
  {
      if (!self.flags[value])
          return false; // not there
      self.flags[value] = false;
      return true;
  }

  function contains(Data storage self, uint value)
      returns (bool)
  {
      return self.flags[value];
  }
}


contract C {
    using Set for Set.Data; // 这是至关重要的变化
    Set.Data knownValues;

    function register(uint value) {
        // 这里，Set.Data类型的所有变量都有相应的成员函数。 以下函数调用与Set.insert（knownValues，value）相同
        require(knownValues.insert(value));
    }
}

也可以这样扩展基本类型：

pragma solidity ^0.4.0;

library Search {
    function indexOf(uint[] storage self, uint value) returns (uint) {
        for (uint i = 0; i < self.length; i++)
            if (self[i] == value) return i;
        return uint(-1);
    }
}


contract C {
    using Search for uint[];
    uint[] data;

    function append(uint value) {
        data.push(value);
    }

    function replace(uint _old, uint _new) {
        // This performs the library function call
        uint index = data.indexOf(_old);
        if (index == uint(-1))
            data.push(_new);
        else
            data[index] = _new;
    }
}

请注意，所有库调用都是实际的EVM函数调用。 这意味着，如果您传递内存或值类型，将执行一个副本，甚至是自变量。 只有当使用存储参考变量时才会执行副本。