Solidity 其它高级特性

pragma solidity ^0.4.0;
library Set {
    // We define a new struct datatype that will be used to
    // hold its data in the calling contract.
    struct Data { mapping(uint => bool) flags; }
    // Note that the first parameter is of type "storage
    // reference" and thus only its storage address and not
    // its contents is passed as part of the call.  This is a
    // special feature of library functions.  It is idiomatic
    // to call the first parameter 'self', if the function can
    // be seen as a method of that object.
    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) {
    // The library functions can be called without a
    // specific instance of the library, since the
    // "instance" will be the current contract.
    if (!Set.insert(knownValues, value))
        throw;
  }
  // In this contract, we can also directly access knownValues.flags, if we want.
}

• Library定义了一个数据结构体，用来在调用的合约中使用(库本身并未实际存储的数据)。如果函数需要操作数据，这个数据一般是通过库函数的第一个参数传入，按惯例会把参数名定为self。
• 另外一个需要留意的是上例中self的类型是storage，那么意味着传入的会是一个引用，而不是拷贝的值，那么修改它的值，会同步影响到其它地方，俗称引用传递，非值传递。
• 库函数的使用不需要实例化，c.register中可以看出是直接使用Set.insert。但实际上当前的这个合约本身就是它的一个实例。 这个例子中，c可以直接访问，knownValues。虽然这个值主要是被库函数使用的。
• 当然，你完全可以不按上面的方式来使用库函数，可以不需要定义结构体，不需要使用storage类型的参数，还可以在任何位置有多个storage的引用类型的参数。

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);
    }
}

• 无状态变量(state variables)。
• 不能继承或被继承
• 不能接收ether。
• 这些限制将来也可能被解除！

pragma solidity ^0.4.0;
// This is the same code as before, just without comments
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; // this is the crucial change
    Set.Data knownValues;
    function register(uint value) {
        // Here, all variables of type Set.Data have
        // corresponding member functions.
        // The following function call is identical to
        // Set.insert(knownValues, value)
        if (!knownValues.insert(value))
            throw;
    }
}

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;
    }
}

• 在storage槽中第一项是按低位对齐存储（lower-order aligned）（译者注：意味着是大端序了，因为是按书写顺序。）。
• 基本类型存储时仅占用其实际需要的字节。
• 如果基本类型不能放入某个槽位余下的空间，它将被放入下一个槽位。
• 结构体和数组总是使用一个全新的槽位，并占用整个槽(但在结构体内或数组内的每个项仍遵从上述规则)

pragma solidity ^0.4.4;
contract C {
    struct s { uint a; uint b; }
    uint x;
    mapping(uint => mapping(uint => s)) data;
}

data[4][9].b的位置在keccak256(uint256(9) . keccak256(uint256(4) . uint256(1))) + 1

• 0-64：哈希方法的暂存空间(scratch space)
• 64-96：当前已分配内存大小(也称空闲内存指针(free memory pointer))

var x = 7;
data[7] = 9;
if (data[x] != x + 2)
    return 2;
else
    return 1;

data[7] = 9;
return 1;

contract FunctionSelector {
    function select(bool useB, uint x) returns (uint z) {
        var f = a;
        if (useB) f = b;
        return f(x);
    }
    function a(uint x) returns (uint z) {
        return x * x;
    }
    function b(uint x) returns (uint z) {
        return 2 * x;
    }
}