solidity学习记录 结构体storage与memory转换

solidity学习记录 storage与memory

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;
contract structtest{
    struct student{
        uint age;
        string name;
    }
    student stu;  //默认storage类型

    // storage stu到 storage s的传递，不是副本，是指向 s是指针，指向stu，
    function test(student storage s) internal {  
        //s 传递给 meimei
        //meimei就是 s 就是 stu
        //meimei指向s s指向stu
        student storage meimei = s;
        meimei.name = "chen";
    }
    
    //返回值在命令窗口展看 output查看  输出 chen （发生改变）
    function  futest() public returns (string memory) {
        test(stu);
        return stu.name;
    }
}

storage 转 storage 是指针传递 修改后面的值，最开始的storage变量(stu) （改变）

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

contract structtest{
    struct  student{
        uint age;
        string  name;
    }
    student stu;  //storage
    // storage
    // storage到 storage 的引用传递，不是副本，是指向，和指针类似，
    function test(student memory s) internal {  
        
        //memory s 传递给 storage stu
        //修改s 的成员，对于stu 不产生影响
        stu = s;
        s.name = "chen";
        //如果修改后 再进行传递，对于修改后的s 传递过去，就会改变stu 
        // stu = s;
    }
    // 显示的是 tmp的参数， s的修改不起作用
    function  futest() public returns (string memory) {
        
        student memory tmp = student(10,"tmp");
        test(tmp);
        return stu.name;
    }
  

memory 转 storage 在 memory中修改，不影响storage（不变），除非修改后再赋值给storage（改变）

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

contract structtest{
    struct  student{
        uint age;
        string  name;
    }
    
    student stu = student(100,"stu");  


    // 内存memory不能改变全局变量storage
    //storage s 形参 是一个指针，引用传递 
    function test(student storage s) pure internal {  
        //meimei 内存中的一个副本
        //storage到 memory， 是叫拷贝
        //s 拷贝到 meimei
        student memory meimei = s;
        //修改内存的，不会影响storage
        meimei.name = "chen";
    }
    
    // 还是stu，修改memory 不改变storage 
    function  futest() public view returns (string memory) {
        test(stu);
        return stu.name;
    }

}

storage 转memory 修改内存中的值，不影响storage（不变）

// SPDX-License-Identifier: MIT
pragma solidity ^0.7.0;

contract structtest{
    
    struct  student{
        uint age;
        string  name;
    }
    
    
//memory转memory 是 指针传递
    
    
//s 赋值给 lina     lina 指向 s

    function test(student memory s) pure internal {  
        
        student memory lina = s;
        //对lina修改 等于 修改 s 等于修改 meimei
        lina.name = "chen";
    }
    

    function  futest() public pure returns (string memory) {
        student memory meimei =  student(100,"chen");
        
        //meimei 传参给 s   等于 meimei复制给 s   s指向meimei
        test(meimei);
        return meimei.name;
    }

}

memory转memory 是指针传递，建立指向后，修改后面的变量，会改变前面的 （改变）

1. memory -> memory 指针引用（修改memory 会改变memory ）
2. storage ->storgae 指针引用 （修改storgae 会改变storage ）
3. storage ->memory 传递到副本，副本修改，（修改副本memory不改变storage）
4. memory ->storage 传递到副本，副本修改，（修改副本memory 不改变memory ）（修改前传递与修改后传递结果相反）