Solidity學習程序：storage與memory

pragma solidity >=0.5.0;


contract memoryTest{
    uint[] arrx;//這個狀態變數存盤在區塊鏈網路上
    
    //會為arry在記憶體中分配空間
    function test(uint[] memory arry) public returns(uint){
        arrx = arry;//將記憶體中的arry拷貝到區塊鏈的arrx上
        //當我們在函式體內部定義了一個可變長度的陣列時，實際上，它默認的型別是storage型別，指向        
        //arrx，所以修改Z元素的時候，實際上是在操作arrx
        
        uint[] storage Z = arrx;
        
        Z[0] = 100;
        
        // Z.length = 100;
    }
    
    
    function test2() public returns(uint){
        
        return arrx[0];
    }
    
     function test3() public returns(uint){
        
        return arrx.length;
    }
}

結構體

pragma solidity >=0.5.0;

contract structTest{
    //結構體定義
    struct student{
        uint grade;
        string name;
        
    }
     //結構體不可以包含自己本身，但可以是動態長度陣列，也可以是映射
     struct student2{
        student2[] stu;
        mapping(uint=>student2) stud;
    }
    //結構體初始化方式
    function init()public view returns(uint,string memory){
        student memory s = student(100,"tck");
        return(s.grade,s.name);
    }
    //結構體初始化第二種方式
    function init2()public view returns(uint,string memory){
        student memory s = student({grade:100 ,name:"tck"});
        return(s.grade,s.name);
        
    }
}

結構體中的mapping

pragma solidity >=0.5.0;

contract structTest{
    //
    struct student{
        uint grade;
        string name;
        
    }
    struct student2{
        student2[] stu;
        mapping(uint=>string) map;
    }
    function init()public view returns(uint,string memory){
        //在初始化結構體的時候，忽略掉這樣的mapping型別
        student memory s = student(100,"tck");
        
        // s.map[0] = "hello"不能用memory操作結構體中d操作結構體中的mapping 
        return(s.grade,s.name);
    }
    
    
}

結構體作為函式引數

pragma solidity >=0.5.0;

contract structTest{
    
   
    struct student{
        uint grade;
        string name;
        
    }
    //
    function test(student memory s) internal {
        
        // student stu = s;stu默認是storage型別，不能用memory型別的s賦值給stu
    } 
    
    
}

storage轉storage

pragma solidity >=0.5.0;

contract structTest{
    
   
    struct Student{
        uint grade;
        string name;
    }
    Student  student;
    
    //
    function getstudent(Student storage s) internal  returns(Student memory){
        
       Student storage stu1 = s;
       stu1.name = "tck";
       
       return stu1;
    } 
    
    function call()  public returns(string memory){
        
        return  getstudent(student).name;
    }
}

memory轉storage

pragma solidity >=0.5.0;

contract structTest{
    
   
    struct Student{
        uint grade;
        string name;
    }
    Student  stu;
    
    //函式形參記憶體中開辟空間
    function test(Student memory s)  internal{
        //把s的值賦給區塊鏈上的stu
        stu = s;

        //修改函式形參的s，只是修改了其記憶體中的空間，沒有修改區塊鏈上的，兩個完全獨立
        s.name = "tck";
    }
    
    function call() public returns (string memory){
        //記憶體中開辟空間
        Student memory temp = Student(100,"tck");
        
        test(temp);
        
        return stu.name;
}
}

storage轉memory

pragma solidity >=0.5.0;

contract structTest{
    
   
    struct Student{
        uint grade;
        string name;
    }
    Student  stu = Student(100,"stu");
    
    //s是一個形參
    function test(Student storage s)  internal{
        //tck是記憶體中的副本，把s參考的stu的內容拷貝給了記憶體中tck物件
        Student memory tck = s;
        //修改tck的值不會修改stu的值
        tck.name = "tangcongke";
    }
    
    function call() public returns (string memory){
        
       
        test(stu);
        
        return stu.name;
}
}

memory轉memory

pragma solidity >=0.5.0;

contract structTest{
    
   
    struct Student{
        uint grade;
        string name;
    }
    
    
    function test(Student memory s)  internal{
        Student memory wong = s;
        wong.name = "wonghui";
    }
    
    function call() public  returns (string memory){
        
        Student memory tck = Student(100,"tck");
        test(tck);
        return tck.name;
}
}