可见性或权限控制(Visibility And Accessors)

可见性

• external 外部可见性
  可以被其它合约或发起交易的方式调用
  在合约内部调用要使用this.f()
• public 公开可见性
  public类型的状态变量，会自动创建一个访问器
• internal 内部可见性
• private 私有可见性

| | 合约内部 | 继承合约 | 外部合约 | 发起交易
| ------------ | ------------ | ------------ | ------------
| external | Y | Y | Y | Y
| public | Y | Y | Y | N
| internal | Y | Y | N | N
| private | Y | N | N | N

函数默认是public
状态变量默认的可见性是internal

访问函数(Getter Functions)

public的状态变量，编译器会默认创建访问函数。

contract C{
    uint public data = 10;
}

变量data为public，所以创建访问函数如下：

function data() view return (uint data)

外部可以使用C.data()访问它。

注意：在外部函数中的状态变量访问，只能通过this.data()的方式。

比如：

contract C{
    uint public c = 10;
    function accessInternal() internal returns (uint){
        return c;
    }
    
    function accessExternal() external returns (uint){
        return this.c();
    }
}

注意：public的mapping默认访问参数是需要参数的，并不是之前说的访问函数都是无参的。
如下：

mapping (address => uint256) public balanceOf;
function balanceOf(address _owner) view returns (uint256 balance)

函数修改器(Function Modifiers)

http://www.tryblockchain.org/Solidity-FunctionModifiers-%E5%87%BD%E6%95%B0%E4%BF%AE%E6%94%B9%E5%99%A8.html
修改器(Modifiers)可以用来轻易的改变一个函数的行为。比如用于在函数执行前检查某种前置条件。

• 修改器(Modifiers)可以被继承
• 修改器(Modifiers)可以被重写（override）
• 修改器(Modifiers)可以接收参数的
• _表示修改器(Modifiers)修饰的函数体替换位置

pragma solidity ^0.4.0;

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

    // This contract only defines a modifier but does not use
    // it - it will be used in derived contracts.
    // The function body is inserted where the special symbol
    // "_;" in the definition of a modifier appears.
    // This means that if the owner calls this function, the
    // function is executed and otherwise, an exception is
    // thrown.
    modifier onlyOwner {
        if (msg.sender != owner)
            throw;
        _;
    }
}


contract mortal is owned {
    // This contract inherits the "onlyOwner"-modifier from
    // "owned" and applies it to the "close"-function, which
    // causes that calls to "close" only have an effect if
    // they are made by the stored owner.
    function close() onlyOwner {
        selfdestruct(owner);
    }
}


contract priced {
    // Modifiers can receive arguments:
    modifier costs(uint price) {
        if (msg.value >= price) {
            _;
        }
    }
}


contract Register is priced, owned {
    mapping (address => bool) registeredAddresses;
    uint price;

    function Register(uint initialPrice) { price = initialPrice; }

    // It is important to also provide the
    // "payable" keyword here, otherwise the function will
    // automatically reject all Ether sent to it.
    function register() payable costs(price) {
        registeredAddresses[msg.sender] = true;
    }

    function changePrice(uint _price) onlyOwner {
        price = _price;
    }
}

例子：使用修改器实现的一个防重复进入锁

pragma solidity ^0.4.0;
contract Mutex {
    bool locked;
    modifier noReentrancy() {
        if (locked) throw;
        locked = true;
        _;
        locked = false;
    }

    /// This function is protected by a mutex, which means that
    /// reentrant calls from within msg.sender.call cannot call f again.
    /// The `return 7` statement assigns 7 to the return value but still
    /// executes the statement `locked = false` in the modifier.
    function f() noReentrancy returns (uint) {
        if (!msg.sender.call()) throw;
        return 7;
    }
}