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]}
posted on
2018-02-28 14:57
北京涛子 阅读(
...) 评论(
)
编辑
收藏
转载于:https://www.cnblogs.com/liujitao79/p/8483644.html
