通学智能合约系列（二十一）--结构体＜下＞

柔情只为你懂 2022-10-13 12:42 154阅读 0赞

大家好，通学技术，学通技术，让我们一起继续来看看智能合约结构体`memory`和`storage`类型转换吧~

#### 6、结构体storage转storage详解 ####

hello，大家好，我们紧接着上节内容来看看，结构体关于`storage`和`memory`类型的转换。

我们先来看一个例子：

pragma solidity ^0.4.16;
    
    
    contract StructTest{ 
        
        struct Student{ 
            string name;
            string grade;
        }
        
        Student student;
        
        function getStudent(Student storage stu) internal returns(Student){ 
            Student storage stu1 = stu;
            
            stu1.name = "tong xue ji shu ";
            
            stu1.grade = "social people";
            
            return stu1;
            
        }
        
        function test() view returns(string) { 
             
             return getStudent(student).name;
        }
     }

编译执行后，我们得到了`tong xue ji shu`，我们知道了对合约中作为全局变量的结构体默认类型是`storage`的。我们的`getStudent`方法形参也是`storage`的，通过调用我们的test方法，将全局变量`student`以引用的方式传递给了我们的形式参数`stu`，最终修改了我们的全局变量的值。说起来还是挺简单的。

#### 7、结构体memory转storage详解 ####

那么如果，我们将`memory`赋值给`storage`呢？

pragma solidity ^0.4.16;
    
    
    contract StructTest{ 
        
        struct Student{ 
            string name;
            string grade;
        }
        
        Student student;
        
        function getStudent(Student memory stu) internal returns(Student){ 
            student = stu;
            
            stu.name = "tong xue ji shu ";
            
            stu.grade = "social people";
            
            return stu;
            
        }
        
        function test() view returns(string) { 
            
            Student memory tmp = Student("xiao wang","gao 2");
            
            getStudent(tmp);
             
            return student.name;
        }
     }

大家可以先思考下，上面这个`test`函数的执行结果是什么呢？以上的代码执行逻辑可以简要概括如下：

1.  我们初始化了一个`Student`类型的`tmp`结构体
2.  然后我们调用`getStudent`函数，将`tmp`拷贝了一份副本赋值给了`stu`，
3.  然后我们再将`stu`赋值给了`student`，
4.  最后，我们输出`student.name`，结果自然是展示 `xiao wang`;

我们在来看一个例子:

pragma solidity ^0.4.16;
    
    
    contract StructTest{ 
        
        struct Student{ 
            string name;
            string grade;
        }
        
        Student student;
        
        function getStudent(Student memory stu) internal returns(Student){ 
            
            stu.name = "tong xue ji shu ";
            
            stu.grade = "social people";
            
            student = stu;
            
            return stu;
            
        }
        
        function test() view returns(string) { 
            
            Student memory tmp = Student("xiao wang","gao 3");
            
            getStudent(tmp);
             
            return student.name;
        }
     }

这段代码仅仅是将`getStudent`函数中关于`stu`结构体的赋值的顺序做了调整。那么他的答案又是什么呢?

我们依然是来分析一下他的执行逻辑：

1.  我们初始化了一个`Student`类型的`tmp`结构体
2.  然后我们调用`getStudent`函数，将`tmp`拷贝了一份副本赋值给了`stu`，
3.  我们对`stu`对象重新赋值了`tong xue ji shu`.
4.  然后我们再将`stu`赋值给了`student`，
5.  最后，我们输出`student.name`，结果自然是展示 `tong xue ji shu`;

代码执行的顺序，很重要，在写智能合约的时候，大家一定要注意哦。

#### 8、结构体storage转memory详解 ####

如果将`storage`传给`memory`又会发生什么呢?

pragma solidity ^0.4.16;
    
    
    contract StructTest{ 
        
        struct Student{ 
            string name;
            string grade;
        }
        
        Student student = Student("xiao wang","gao 3");
        
        function getStudent(Student storage stu) internal returns(Student){ 
            
            Student memory tudent = stu;
            
            tudent.name = "tong xue ji shu ";
            
            tudent.grade = "social people";
            
            
            return tudent;
            
        }
        
        function test() view returns(string) { 
        
            getStudent(student);
             
            return student.name;
        }
     }

我们依然是来分析一下他的执行逻辑：

1.  我们初始化了一个`Student`类型的`student`结构体
2.  然后我们调用`getStudent`函数，将`student`引用指向了`stu`，
3.  然后我们将`stu`又赋值给了内存中的`student`
4.  接着我们对`student`对象重新赋值了`tong xue ji shu`.
5.  最后，我们输出`student.name`，结果显示了`xiao wang`;
    
    这个说明，我们的内存中的修改，依然是不会影响区块链上的内容的。

#### 9、结构体memory转memory详解 ####

hello，大家好，我们最后来看看 `memory`转`memory`。

pragma solidity ^0.4.16;
    
    
    contract StructTest{ 
        
        struct Student{ 
            string name;
            string grade;
        }
    
        
        function getStudent(Student memory stu) internal returns(Student){ 
            
            Student memory tongtong = stu;
            
            tongtong.name = "tong xue ji shu ";
            
            tongtong.grade = "social people";
            
            
            return tongtong;
            
        }
        
        function test() view returns(string) { 
            Student memory meimei = Student("meimei","3");
            
            getStudent(meimei);
             
            return meimei.name;
        }
     }

编译执行后，你会发现，答案竟然是`tong xue ji shu`.难道是想让你们点赞、在看、分享？

那肯定不是滴，这是因为`solidity`中为我们做了优化，`memory`实参转给`memory`形参是指针指向，所以最终结果

好了 ，到这一部分，我们关于智能合约 语言`solidty`的语法就介绍基本介绍完了，留下最后的枚举我们下节说，另外 我们在好好回顾总结下。这里的结束其实仅仅使我们真正要买入区块链技术的开始。让我们一起打起精神来，进行 更有意思的学习吧~