solidity学习记录4 （函数的初步入门）

函数的重载

函数重载是指函数命名相同的函数，但需要满足以下两个条件之一

函数入参的数量不同
函数入参的类型不同

注意：address类型与uint160 类型相同，若重载函数参数是两个类型则会报错

pragma solidity ^0.4.0;

//函数的重载
//1 函数的名字相同  2函数的 参数(类型 数量)不同  3.返回的值类型不同不能被重载
//注意uint160 与address
contract chongzai{
    function fun(uint num) view public returns(uint){

    }
      function fun(uint8 num) view public returns(uint){

    }
    uint public a = 1;
    function test1(uint num){
        a=100;
    }
    function test1(uint8 num)
    {
        a=200;
    }
    function test()
    {
        test1(288);
    }
}

函数入参

函数入参有两种方式

按照顺序依次向函数传入参数
将参数用对象的方式传入，不用按照顺序

pragma solidity ^0.4.0;
contract funcParam{
    uint public num;
    string public name;

    function setParam(uint _num,string _name) view public{
        num = _num;
        name = _name;
    }
    function test()
    {
        setParam(10,"waston");   
    }
    function test2(){
        setParam({_name:"万事通",_num:100});
    }
}

函数的返回值

函数返回值声明中可以定义变量
函数可以返回多个值
函数的返回值可以是形参
可以在函数返回值进行计算

pragma solidity ^0.4.0;
contract funReturn{
    function returnTest() view public returns(uint mul)
    {
        uint a = 10;
        return a;
    }
    function returnTest2() view public returns(uint mul)
    {
      mul=100;
    }
    function returnTest3() view public returns(uint mul)
    {
      mul=100;
        uint a = 10;
        return a;
    }
     function returnTest4(uint a,uint b) view public returns(uint add,uint mul)
    {
        add = a+b;
        mul=a*b;
    }
    function returnTest5(uint a,uint b) view public returns(uint add,uint mul)
    {
       return (a+b,a*b);
    }
     function returnTest7(uint a,uint b) view public returns(uint add,uint mul)
    {
       return (10,20);
    }

     function returnTest8(uint a,uint b) view public returns(uint a1,uint a2)
    {
       return (b,a);
    }

}

modifire

pragma solidity ^0.4.0;
contract modifireTest{
    address public owner;
    uint public num=0;
    //把合约的部署着地址存储再owner变量中
    constructor (){
        owner = msg.sender;
    }
    //定义modifire  
    modifier onlyOwner{
        //判断
        require(msg.sender==owner);
        _;  //动态添加
    } 
    //附加上了modifire  先执行了 require(msg.sender==owner);  判断了我们合约的调用者是否等于合约的拥有者  如果成立则会执行下面的语句
    //否则就会回滚报错
    function changeIt(uint _num) onlyOwner{
        num = _num;
    }
}

pragma solidity ^0.4.0;
contract mappingTest{
    //账户ID
   mapping(address =>uint) idMapping;
   mapping(uint => string) nameMapping;
   uint public sum= 0;
//用户只能注册一次
   modifier control{
        require(idMapping[msg.sender]==0);
       _;
   }
   function register(string name)  control
   {
      
       //获取到当前合约的调用者
       address account = msg.sender;
       sum++;
       //将合约的调用者的地址与注册总量id联系在一起
 
        idMapping[account]=sum;
        //将用户id与用户注册的名字绑定在一起
       nameMapping[sum] =name;
   }
   //通过地址获取到id
   function getIdByAddress(address are) view public returns(uint)
   {
       return idMapping[are];
   }
   //通过id获取到name
 
   function getNameById(uint id) view public returns(string)
   {
       return nameMapping[id];
   }
}

pragma solidity ^0.4.0;
contract modifierTest2{
    uint public level = 9;
    string public name = "waston";
    uint public DNA;
    //函数的modifire 可以有参数
    modifier contrlLevel(uint needlevel){
        require(level>needlevel);
        _;
    }
    //使用modifire  增加代码的重用性 和扩展性
    function changeName()  contrlLevel(2){
     
        name="万事通";
    }
    function changeDna()  contrlLevel(10){
           
            DNA=999;
    }
    

}

modifire 执行顺序

pragma solidity ^0.4.0;
//多重modifire
contract mulModifire{
    uint public a = 0;

    modifier mod1{
        a = 1;
        _;
        a=2;
    }
    modifier mod2{
        a=3;
        _;
        a=4;
    }
    //modifire 的执行顺序a=1   a=100 a=2 
    //函数中的替代了modifire中的_;
      function test1() mod1{
        a=100;
    }   

    //执行顺序  a=1 a=3 a=100 a=4 a=2
    function test() mod1 mod2{
        a=100;
    }
}

函数的继承

pragma solidity ^0.4.0;

contract grandFather{
    uint public gudong=200;
    function zhongdi() public returns (string)
    {
        return "zhongdi";
    }
}


contract father is grandFather{
    uint public money =10000;
    function dahan() public returns(string){
           return "dahan"; 
    }

}
//合约能够被连续的继承
//son这个合约继承了father这个合约
contract son is father{
    function getMoney() returns (uint){
        //继承了父亲money这个属性
           return money; 
    }
    //继承了父亲dahan 这个函数  行为
    function test(){
        dahan();
    }
    //继承了爷爷种地这个函数 行为  连续继承
      function test2(){
        zhongdi();
    }
    function getGudong() returns(uint){
        return gudong;
    }
}

pragma solidity ^0.4.0;
//1.如果属性不加上任何的修饰符 是可以被继承的
//2.加上了public属性后也是可以被继承的
//3 internal属性仍然是可以被继承的
//4 external编译报错 没有修饰符
//5 private 编译报错 因为private代表只有父类有这个属性不能被继承
// internal修饰的函数只能够在合约的内部或者继承的合约的内部使用  但是不能够在合约的外部使用
// external修饰的函函数不能够在内部调用   也不能在继承的合约内部调佣 
contract father {
    uint money=10000;
    // uint public money=10000;
    // uint external money=10000;
    // uint private money = 10000;
    function dahan() external  returns (string)
    {
        return "dahan";
    }
    //间接的在内部调用只能使用this指针
    function  dahanTest() public view {
        this.dahan();
    }
}
//external修饰的函数调用的第二种方式在另一个合约内创建或引用合约的“地址”来使用
contract externalTest{
    father f = new father();
    function externalTestIt() returns(string)
    {
        return  f.dahan();
    }
  
}
contract son is father{
    // function getMoney() public view returns (uint)
    // {
    //     return money;
    // }
    // function test() public view returns (string){
    //     return dahan();
    // }
}

函数小结

1 private不能够被继承也不能在外部被调用可以在内部被调用（所有的修饰符都这个）
2 internal 不能在外部被调用可以被继承
3 external不能够在内部被调用只能够在外部调用可以被继承如果强行调用通过“地址。”
4 public 权限最大可以在外部内部调用可以被继承
5 pure 不会读取全局变量更不会修改全局变量一个固定的输入就会有一个固定的输出
6 constant 在函数中和view相同 ,在全局变量中致用户bytes1-bytes32 uint int string 代表数据不能被修改
7 view 只读取全局变量的值不能修改他不消耗gas
8 payable转账的时候必须要加的关键字
9 命名参数 {value:2,name:'wastoner'}
10 函数可以有多个返回值