美文网首页Solidity智能合约专题
Solidity的storage、memory、calldata

Solidity的storage、memory、calldata

作者: 梁帆 | 来源:发表于2022-08-12 00:24 被阅读0次

一、变量类型

官方文档在:https://docs.soliditylang.org/en/v0.8.14/types.html

在这里,我们主要注意的是引用类型

  • 数组(string和bytes也是独特的数组)
  • 结构体(struct)
  • 映射(mapping)

在Solidity中使用引用类型的时候,就需要指定数据的位置。

二、数据存储位置(Data Location)

以太坊中,有两个地方可以存储变量:那就是

  • storage
  • memory(包括calldata和stack)

将它类比于我们使用的pc构件的话,storage就相当于硬盘空间,memory就是我们的内存空间。区块链中,“硬盘空间” storage永久存储在区块链中的变量,而“内存空间” memory 则是临时存储的,当外部函数对合约调用完成时,内存型变量就会被移除。
memory位置还可以细分为calldatastack两种位置。

1.storage

Storage变量是指永久存储在区块链中的变量。
当我们创建合约时,写的状态变量就默认是storage类型的:

pragma solidity ^0.8.0;

contract Person {
    struct State {
        string name;
        string gender;
    }
    State public state;
}

比如上面这个合约中,state的值就在storage中。
除了用在状态变量意外,对于privateinternal的函数中,存储位置可以声明成storage

contract Person {
    struct State {
        string name;
        string gender;
    }

    State public state;

    function setState(string calldata _name, string calldata _gender) external {
        state.name = _name;
        state.gender = _gender;
    }

    function emptyName() external {
        _emptyName(state);
    }

    function _emptyName(State storage self) internal {
        self.name = "";
    }
}

从上面代码可以看出,storage作为internal函数的参数的用法,这样就相当于c语言中传了个指针进去,这样就能通过传入的指针参数来修改storage中的值了。
试想一下,这里的_emptyName函数参数改成memory或者calldata是个什么样的效果——编译器会提示你,可以加上pure修饰符,pure修饰符即代表这个函数不读取状态状态,也不修改状态变量,可想而知,这里storage的作用在哪儿。
但这里storage的作用体现其实不太明显,因为很显然有更简单的写法——即直接用state来修改。其实storage,平时主要还是搭配library来使用的,这样可以提供更好的抽象,且看以下的代码:

pragma solidity ^0.8.0;

library PersonManager {
    struct State {
        string name;
        string gender;
    }

    function setState(State storage self, string calldata _name, string calldata _gender) public {
        self.name = _name;
        self.gender = _gender;
    }

    function changeName(State storage self, string calldata newName) public {
        self.name = newName;
    }
}

contract Person {
    PersonManager.State public state;

    function initState(string calldata _name, string calldata _gender) external {
        PersonManager.setState(state, _name, _gender);
    }

    function changeName(string calldata _name) external {
        PersonManager.changeName(state, _name);
    }
}

library中,我们没有定义(也不能定义)状态变量,只有当Person合约用到library的时候,才会把自身的状态变量作为参数值传递进去,这样可以做到修改自身状态变量的作用。
这个案例是storage最常用的场景。

2.memory

Memory 变量则是临时的,当外部函数对某合约调用完成时,内存型变量即被移除。

pragma solidity ^0.8.0;

contract Person {
    struct State {
        string name;
        string gender;
    }

    State public state;

    function setState(string calldata _name, string calldata _gender) external {
        state.name = _name;
        state.gender = _gender;
    }

    // string用作函数返回值的存储位置
    function getName() external view returns (string memory) {
        return state.name;
    }

    // string用作函数内临时变量的存储位置
    function changeGender(uint value) external {
        require(
            value == 0 || value == 1,
            "Person: Input value error"
        );
        string memory newGender;
        if(value == 0) {
            newGender = "female";
        } else {
            state.gender = "male";
        }
        state.gender = newGender;
    }
}

如上述代码所示,memory可用于函数返回值的存储位置,也可以作为函数内临时变量的存储位置,这两个位置如果都是引用类型的数据,而不特别指定为memory的话,是无法通过编译的。

3.calldata

calldata一般作为external或者public函数的参数使用,如上面代码中的setState函数,两个参数_name_gender,都特别指定了是calldata类型。
在官方文档中,是这么形容calldata类型的:

Calldata is a non-modifiable, non-persistent area where function arguments are stored, and behaves mostly like memory.

calldata有以下特征:

  • 它只能用于函数声明参数(而不是函数逻辑)

  • 它是不可变的(不能被覆盖和更改)

  • 它必须用于external函数的动态参数

  • 它是临时的(该值在事务完成后会销毁)

  • 它是最便宜的存储位置

这里如果指定为memory类型也是可以的,但是calldata是const的,比较符合我们的需求,而且最为便宜,所以用calldata。

4.stack

stack 保存很小的局部变量,免费使用,但有数量限制。

pragma solidity ^0.8.0;

contract Counter {
    function start() external returns (uint sum) {
        uint a1 = 1;
        uint a2 = 1;
        uint a3 = 1;
        uint a4 = 1;
        uint a5 = 1;
        uint a6 = 1;
        uint a7 = 1;
        uint a8 = 1;
        uint a9 = 1;
        // uint a10 = 1;
        // uint a11 = 1;
        // uint a12 = 1;
        // uint a13 = 1;
        // uint a14 = 1;
        // uint a15 = 1;
        // sum = a1+a2+a3+a4+a5+a6+a7+a8+a9+a10+a11+a12+a13+a14+a15;
        sum = a1+a2+a3+a4+a5+a6+a7+a8+a9;
    }

此时所有的stack变量,即非引用型数据,大概有10个,此时编译会出错,提示我们栈过深:

栈过深的报错
当我们将a9注释掉,就能正常编译通过,这里我们尝试编译通过的栈深临界点应当是9个,但是有的文章里用的address变量测栈深,测出来的是16个。这应该跟两种变量的长度有关,uint默认为uint256,为256位;而address类型长度为20×8=160位。
有关Stack too deep的解决方法,可以看这个网站,这里有详细的解决方案:
https://soliditydeveloper.com/stacktoodeep

三、总结

  • 状态变量的存储方式都是 storage;
  • 局部变量的存储方式可以声明成 storage、memory 或 calldata;
  • 公用函数(public)和外部函数(external)中,函数参数的存储方式只能是 memory 或 calldata;
  • 私有函数(private)和内部函数(internal)中,函数参数的存储方式还可以是 storage;
  • 映射(mapping)只能存储在 storage 中,且不能在函数内部定义,映射一般声明为状态变量;
  • 一般建议将函数参数声明为calldata,因为gas费会比较低。

相关文章

网友评论

    本文标题:Solidity的storage、memory、calldata

    本文链接:https://www.haomeiwen.com/subject/mhtkbrtx.html