以太坊solidity内存(memory与storage)与结构体

1.memory与storage的区别

• 函数外部声明的变量默认储存在storage里（全局变量）
• 函数内部声明的变量默认储存在memory里（局部变量）

pragma solidity ^0.4.0;

// Storage变量是指永久存储在区块链中的变量
// Memory 变量是临时的，当外部函数对某合约调用完成时，内存型变量即被移除
// 内存(memory)位置还包含2种类型的存储数据位置，一种是calldata，一种是栈（stack）

contract memoryTest{
    // storage（区块链）和memory（内存）的最大区别：storage在区块链中是永久保存的数据，类似一部分全局变量
    // 而memory在内存中产生，也同时随着内存销毁，不是永久保存的
    
    uint public num1 = 5;

    // 以下变量中的num、i、j均存储于内存中
    function add(uint num) view returns(uint){
        num = num+1;
        return num;
    }
    
    function test() view returns(uint,uint){
        uint i = 2 ;
        uint j = add(i);
        return (i,j);
    }
    
    // 修改区块链上的值
    function changeIt(){
        num1 = 1000;
    }

 2.结构体storage转storage

1.要是函数以结构体作为参数，那么函数修饰符必须有private/internal
2.storage可以接受storage的值，并且storage的改动影响其它storage
 

contract STS{   //此例temp，student1均为storage
    struct stu{
        uint id;
        string name;
    }
    stu student1;
    function structtest(stu storage temp) internal{ //传入storage结构体
        student1=temp; //赋值
        temp.id=2;    //即使只是修改并未再次赋值，student1的id也会改变
    }
    
    function tets() public view returns(uint){
        structtest(student1); 
        return (student1.id);
    }
    
}

 3.结构体中的mapping特性

pragma solidity ^0.4.0;

contract structTest{
    
    struct student{
        uint grade;
        string name;
        
        mapping(uint=>string) map;
    }
    
    student meimei; // 默认为storage类型，只能够用storage类型来操作结构体中的mapping类型
    
    function init() view returns(uint,string,string){
    	// 1.初始化时忽略mapping类型
        student memory s = student(100,"BuLiangShuai");
        // s.map[0] = "HelloWorld"; 2.不能直接用memory类型的对象直接操作struct中的mapping类型
        meimei = s; // 将内存中的s对象赋值给像meimei这种区块链网络上的storage
        meimei.map[0] = "HelloWorld"; // 我们只能通过storage对象来操作结构体中的mapping属性
        return (s.grade,s.name,meimei.map[0]);
    }
    
}

 

4.结构体memory转storage

1.要是函数以结构体作为参数，那么函数修饰符必须有private/internal
2.storage可以接受memory的值
3.memory的改动不影响storage
4.storage的改动不影响memory

pragma solidity ^0.4.0;

contract structTest{
    
    struct student{
        uint grade;
        string name;
    }
    
    student stu;
    
    // 函数的形参传递了指针
    function test(student memory s) internal{
    	// 把s的值赋值给了区块链上的stu
        stu = s;
        // 修改函数形参的s，只是修改了其内存中的空间，没有修改掉区块链上的空间，因为两个空间完全独立
        s.name = "BuLiangShuai";
    }
    
    function call() returns(string){
    	// 内存中开辟空间
        student memory tmp = student(100,"tmp");
        test(tmp);
        return stu.name;
    }
}

5.结构体storage转memory

1.要是函数以结构体作为参数，那么函数修饰符必须有private/internal
2.storage可以接受memory的值
3.memory的改动不影响storage
4.storage的改动不影响memory

pragma solidity ^0.4.0;

contract structTest{
    
    struct student{
        uint grade;
        string name;
    }
    
    student stu = student(100,"stu");
    
    // s形参是引用
    function test(student storage s) internal{
    	// meimei是内存中的一个副本，把s引用的stu的内容拷贝给了meimei这个内存对象
        student memory meimei = s;
        // 修改meimei的值不会修改stu的值，因为两者的空间完全不同
        meimei.name = "BuLiangShuai";
    }
    
    function call() returns(string){
        test(stu);
        return stu.name;
    }
}

6.枚举

1.enum必须要有成员对象
 2.enum中不能有汉字
 3.enum后不能加分号(;)
4.enum的返回值(存储)是uint类型，且满足最小匹配原则返回

pragma solidity ^0.4.0;

contract enumTest{
    
    uint fengjie = 0;
    
    // 1.enum必须要有成员对象
    // 2.enum中不能有汉字
    // 3.enum后不能加分号(;)
    // 4.enum的返回值(存储)是uint类型，且满足最小匹配原则返回
    enum girl{fengjie,binbin,yuanyuan} // 0,1,2
    
    girl dataGirl = girl.fengjie;
    
    function getEnum() view returns(girl){
        return girl.yuanyuan;
    }
    
    function oneNightDate() returns(string){
        require(dataGirl==girl.fengjie);
        dataGirl = girl.binbin;
        return 'data with fengjie';
    }
    
    function secondNightDate() returns(string){
        require(dataGirl==girl.binbin);
        return 'data with binbin';
    }
    
}