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;
}
}