solidity语言10

pragma solidity ^0.4.16;

contract OwnedToken {
    // TokenCreator是个合约类型，由后面部分定义。只要不用于创建新合约，引用它就好
    TokenCreator creator;
    address owner;
    bytes32 name;

    // 构造函数，用于指定创建者和名字
    function OwnedToken(bytes32 _name) public {
        owner = msg.sender;
        creator = TokenCreator(msg.sender);
        name = _name;
    }

    // 变更名字，仅创建者有权修改
    function changeName(bytes32 newName) public {
        if (msg.sender == address(creator))
            name = newName;
    }

    // 转帐，仅属主人有权转帐
    function transfer(address newOwner) public {
        if (msg.sender != owner) return;

        // 检查转帐是否成功，如果返回失败(比如，gas用尽)，立即停止
        if (creator.isTokenTransferOK(owner, newOwner))
            owner = newOwner;
    }
}

contract TokenCreator {
    function createToken(bytes32 name) public returns (OwnedToken tokenAddress) {
        // 建立新token合约，返回地址
        return new OwnedToken(name);
    }

    function changeName(OwnedToken tokenAddress, bytes32 name) public {
        tokenAddress.changeName(name);
    }

    function isTokenTransferOK(address currentOwner, address newOwner) public view returns (bool ok) {
        address tokenAddress = msg.sender;
        return (keccak256(newOwner) & 0xff) == (bytes20(tokenAddress) & 0xff);
    }
}

可见性和访问限制符

函数可以被定义为external, public, internal or private，缺省是 public。对状态变量而言, external是不可能的,默认是 internal。

# external
外部函数是合约接口的一部分,这意味着它们可以从其他合约调用, 也可以通过事务调用。外部函数f不能被内部调用(即 f()不执行,但this.f()执行)。外部函数，当他们接收大数组时，更有效。

# public
公共函数是合约接口的一部分,可以通过内部调用或通过消息调用。对公共状态变量而言，会有的自动访问限制符的函数生成

internal
这些函数和状态变量只能内部访问(即在当前合约或由它派生的合约),而不使用（关键字）this 。

private
私有函数和状态变量仅仅在定义该合约中可见， 在派生的合约中不可见。

pragma solidity ^0.4.0;

contract C {
    uint private data;  // data是私有变量

    function f(uint a) private returns(uint b) { return a + 1; }  // f是私有函数
    function setData(uint a) public { data = a; }
    function getData() public returns(uint) { return data; }
    function compute(uint a, uint b) internal returns (uint) { return a+b; } // compute是内部函数
}

contract D {
    function readData() public {
        C c = new C(); // 合约类型C实例化，生成对象c
        uint local = c.f(7); // 由于f是私有函数，实例c不能调用f函数
        c.setData(3);
        local = c.getData();
        local = c.compute(3, 5); // 由于compute是内部函数，实例c不能调用compute函数
    }
}

contract E is C {
    function g() public {
        C c = new C();
        uint val = compute(3, 5); // E是C的子合约，可直播使用compute内部函数
    }
}

pragma solidity ^0.4.0;

contract C {
    uint public data = 42; //  data是全局变量
}

contract Caller {
    C c = new C();
    function f() public {
        uint local = c.data(); // 实例c允许调用data
    }
}

pragma solidity ^0.4.0;
contract C {
    uint public data;

    function x() public {
        data = 3; // 没有this关键字，内部访问方式，以变量形式进行访问
        uint val = this.data(); // 使用关键字this，外部方式访问，做为函数访问，this代表当前合约
}

复杂一些的示例

pragma solidity ^0.4.0;

contract Complex {
    struct Data {
        uint a;
        bytes3 b;
        mapping (uint => uint) map;
    }

    mapping (uint => mapping(bool => Data[])) public data;
}

function data(uint arg1, bool arg2, uint arg3) public returns (uint a, bytes3 b) {
    a = data[arg1][arg2][arg3].a;
    b = data[arg1][arg2][arg3].b;
}

Data
{ 'a': 1, 'b': x, 'map': { 1:  1}}

data
{ 1: 'true': [ Data]}