solidity_入门5

solidity函数部分

pragma solidity ^0.4.16;

contract functiontest{
    //  函数重载
    //当函数名字相同，要么1.传入的参数类型不同；2.传入的参数数量不同；
    // address的存储类型为uint160;
    
    uint public test= 0;
    function fun1(uint num1,uint num2) {
        test = 10;
    }
    function fun1(uint num1) {
        test = 20;
    }
    
    
    
    function fun2(uint a) {
        test = 100;
    }
    function fun2(string a) {
         test = 200;
    }
    
    
    function fun3(address a) {
        test=1000;
    }
    function fun3(uint160 a){
        test=2000;
    }
    
    
    
    function fun4(uint8 a){
         test=10000;
    }
    function fun4(uint16 a){
        test=20000;
    }
    
    
// 函数参数

    uint public num;
    string public teststring;
    function setvalue(uint num1,string teststring1){
        num=num1;
        teststring = teststring1;
    }
    function setfun(){
        setvalue({num1:1,teststring1:'a'});
    }
    
//返回值同上

//变量作用域
    
    
//constant 修饰符onstant可在函数声明时使用，相当于view。不消耗燃料
//但是此功能4.x版本可用，5.x版本废弃
//constant只能用于全局变量
//constant一旦声明函数的值就不可以修改
//函数内试图修改，结果编译报错
//函数内无法声明constant变量



//构造函数。在合约部署时自动调用一次，而且只能调用这一次
/*新式（推荐）：constructor(参数列表) {}
旧式：function 合约名(参数列表) {} */
    uint public atest;
    function functiontest(){
        atest=100;
    }
    
    /*constructor(){
        a=300;
    }*/

// modifier函数
    /*
    modifier 函数名 (参数列表){ 
    语句;
    _; //代表调用modifier的函数的语句
    语句;
    */
    
    uint public modnum=0;
    modifier modfun1(){
        _;
        modnum =1;
    }
    modifier modfun2(){
        modnum=2;
        _;
    }
    function modtest1() modfun1{
        modnum=100;
    }
    function modtest2() modfun2{
        modnum = 200;
    }
    //还有modifer+require的结合
    
    
}


//简单继承
    //1.通过is标识符来继承contract
    //2. a is b a继承了b   a is b,c  同时继承B,c;
    //子合约会覆盖掉相同的变量和函数
    
    
contract father{
    uint a=1;
    string str= "i am father";
    function fathertest() public view returns(string,uint){
        return(str,a);
    }
    
}

contract son is father{
    uint b=1;
    uint a=100;
    function seefather() public view returns(string){
        return str;
    }
    function changevalue() public view returns(uint){
        return a;
    }
    
}


contract sample{
    // internal 只能在合约内部调用
    //external 只能在合约外部调用
    //public 在合约内外部均可调用
    //使用 this.函数名则视为外部调用
    //private不能够被继承，在合约外部不能被调用，但是在合约内部可以被调用
    /*   继承           变量                                函数
         是          public internal                        public internal external
         否          private external(这个不能修饰变量)       private
    */
    
    uint a=0;
    uint private b=1;
    uint public c= 2;
    uint internal d = 3;
    //uint external e = 4;
    function privatefun() private view returns(string){
        return "private";
    }
    function publicfun() public view returns(string){
        return "public";
    }
    function internalfun() internal view returns(string){
        return "internal";
    }
    function externalfun() external view returns(string){
        return "external";
    }
    
    
    function getfun() public view returns(string){
        //return externalfun(); 只能外部调用；
        return this.externalfun();
    }
    
}

contract sonsample is sample{
    //可以show 上面的修饰符
}


//getter 函数
contract getter{
    
    
    //public 关键字会自动生成一个函数
    uint public num = 1;
    /* 相当于函数
    function getnum() public view returns(uint){
        return num;
    }*/
    
    //使用mapping时也生成，但需要输入参数
    mapping(uint => string) public mappingshow;
    
}



//合约销毁
contract endcontract{
    //调用selfdestruct;
    uint public a=1;
    address owner;
    
    constructor() public{
        owner = msg.sender;
    }
    function killfun() public {
        if (owner == msg.sender)
        {
            selfdestruct(msg.sender);
        }
    }
}