Solidity--5.0重大更新(示例代码)

示例代码

其中 // Error…注释掉的代码在solidity版本<0.5.0均可以编译通过,但是在>=0.5.0均得换成 // Right …的代码才能编译通过.

pragma solidity >0.4.99 <0.6;

contract A {

   function () external payable {}

}    

contract B {

   function () external {}

}

interface ERC20 {

   // function transferFrom(address _from, address _to, uint256 _value) public; // Error, `interface` must declare with `external`

   function transfer(address _to, uint256 _value) external;            // Right

}

contract F

{

   address payable to_pay;

   address to;

   address owner;

   // uint constant time = now;            // Error, value should be compile time constant.

   string constant time = “johnwick.io”;   // Right

   modifier onlyOwner {

       require (msg.sender == owner);

       _;

   }

   // function () {            // Error, fallback function MUST be `external`

   function () external  {     // Right

   }

   // function F() {           // Error, consturctor function should use `constructor` keyword

   // constructor() {          // Error, `constructor` should be `public`

    constructor () public {    // Right

   }

   function payable_or_not() public {

       bool result;

       /* `address payable` VS `address` */

       // to_pay = new A();             // Error, `contract` should explicitly convert to `address`

       to_pay = address(new A());  // Right, fallback function of contract A is `payable`

       to = address(new A());      // Right    

       to_pay.transfer(1);         // Right, `transfer()` is member of `address payable`

       result = to_pay.send(1);    // Right, `send()` is member of `address payable`

       to = address(new B());          // Right

       // to_pay = address(new B());   // Error, fallback function of contract B is not `payable`.

       // to.transfer(1 ether);        // Error, `transfer()` is not member of `address`

       // result = to.send(1 ether);   // Error,  `send()` is not member of `address`

       bool success;

       bytes memory data;

       (success, data)= to.call.gas(0).value(1 ether)(“”);   // However, you can use `call(“”)` to send ether

       address john;

       john = to_pay;          // Right, `address payable` can directly convert to `address`

       address payable wick;

       // wick = to;                   // Error, `address` can’t directly convert to `address payable`

       wick = address(uint160(to));    // Right,  `address` can forcibly convert to `address payable`

       wick.transfer(1 ether);         // `wick` is `address payable` now    

   }

   // struct dummy {}              // Error, empty struct is not allowed.

   struct yummy {string food;}     // Right

   // `external` function input parameter should explicitly declare `calldata` location.

   function transfer(address _to, uint _value, bytes calldata _data)  pure external returns (bool success){

       // return;            // Error, empty return statements for functions with one or more return values are now disallowed.

   }

   // `public` function input parameter should explicitly declare `memory` location.

   function try_some(bytes memory _data) public view returns(bool) {

       if(to == to_pay)

       {

       // throw;                   // Error, `throw` is deprecated.

          revert();                // Right, you should use `assert(),require(),revert()` to raise an exception.

       }

       bytes32 _hash;

       // _hash = sha3(_data);     // Error, `sha3()` is deprecated.

       _hash = keccak256(_data);   // Right

       uint256 _time;

       // _time = 1 years;      // Error, `years` is deprecated, due to the leap year problem.

       _time = 366 days;        // Right

       // var secs = _time * 3600;    // Error, `var` is deprecated.

       uint secs; secs = _time * 0x3600;     // Right

       int256 _value;

       // _value = 0xff wei;    // Error, hex number with unit is not allowed now.

       _value = 0xff*1 wei;    // Right

       // _value = 0Xff*1 wei;  // Error, hex number prefix `0X` is not allowed now.

       // _value = 1. ether;      // Error, dot followed without numbers is not allowed now.

       _value = 1.0 ether;         // Right

      // _value = +1;            // Error

       _value = -1;

       // bytes storage not_initial_bytes;   // Error, `storage` without initialization is not allowed now.

       // uint[0] zero_array;              // Error, fixed-size array of zero length is not allowed now.

       bytes32 b32;

       bytes20 b20;

       bytes1  b1;

       uint256 u256;

       uint160 u160;

       // b32 = bytes32(u160);              // Error, can’t directly convert `uintX` to `bytesY` of different size.

       b32 = bytes32(uint256(u160));       // Right, convert to the same size, then convert to the same type.

       u160 = uint160(bytes20(b32));       // Right

       b32 = bytes32(u256);                // Right, both are the same size, then convert to the same type.

       // b1 = 255;                        // Error

       b1 = bytes1(uint8(255+360));        // Right, decimal number like `uintX` should convert to the same size, then the same type.

       // b16 = 0xff;                      // Error, hex number and `bytesX` are different size.

       b20 = bytes20(uint160(0xff));       // Right, same size, then same type.

       b1 = 0xff;                          // Right, hex number and `bytesX` are the same size

   }

   function im_not_payable() public returns (uint256 _value){

    //   _value = msg.value;                 // Error, `msg.value` MUST be used in `payable` function.

   }

   function im_payable() public payable returns (uint256 _value){

       _value = msg.value;                 // Right, `msg.value` CAN be used in `payable` function.

   }

   // function not_impletement() public onlyOwner; // Error, function without implementation can’t use `modifier`

   function kill(address payable _to) public {

       // suicide(_to);        // Error, `suicide` is deprecated.

       selfdestruct(_to);      // Right

   }

   function scope_() view public {

       uint count = 0 ;

       for (uint i=1 ; i<100; i++){

           count += i;

       }

       // i = now;             // Error, not C99-Style scope

       uint i; i = now;         // Right, but this is error in solidity < 0.5.0 due to variable redefinition.

   }

   event ShowCount(uint);

   function inf_loop() public {

       uint count = 0;

       do {

           if (count!=0) {

               continue;

           }

           count = 1;              // <0.5.0, `continue` jump to this loop body, which results in infinite loop !!!

       }while((count++)<10);       // >=0.5.0 `continue` jump to this condition check.  

       emit ShowCount(count);

   }

}

你可能感兴趣的:(Solidity--5.0重大更新(示例代码))