15.4.1 语言基础与数据位置
所属:全栈开发面试题库 / 15 Web3 与区块链 / 15.4 Solidity 与合约工程
本节要解决的问题
面试里问 Solidity,多数人答"就是合约语言"。这是入门。真正的分水岭是:能不能说清 storage/memory/calldata 的区别、mapping 为什么用 keccak256 算槽位、可见性修饰符的实际作用、以及 0.8.x 的溢出检查。本节解决四个具体问题:一是分清三种数据位置的生命周期与 Gas 成本;二是讲清 mapping 的存储布局(key 不存在也能查,值 = 0);三是把可见性(external/public/internal/private)与 modifier 执行顺序串起来;四是说明 0.8.x 的溢出检查与 unchecked 块的取舍。
学习目标
学完本节,你应当能够:
- 区分 storage/memory/calldata 的生命周期、访问单位、Gas 成本,并说明什么时候用哪个。
- 画出 mapping 的存储布局:key → keccak256(key ++ slot) → 槽位。
- 解释四种可见性修饰符的实际作用,以及 external 与 public 的区别。
- 说明 0.8.x 溢出检查的原理,以及什么时候用 unchecked 块。
先修与前置
- 建议先读 15.3.1 EVM 架构与执行模型 的四区模型。
- 本节是 15.4.2 继承、接口与升级模式 的前置。
知识地图
数据位置:
storage:持久化,2^256 槽,SLOAD/SSTORE,贵
memory:易失,字节数组,MLOAD/MSSTORE,中等
calldata:只读,调用输入,CALLDATALOAD,便宜
值类型:
uint/int/address/bool/bytesNN/枚举
直接存在槽位里
引用类型:
struct/array/mapping/string
存在槽位里的是指针或槽位号
mapping:
key → keccak256(key ++ slot) → 槽位
不存在的 key 查出来 = 0
可见性:
external:只能外部调用
public:外部 + 内部
internal:只内部
private:只本合约
modifier:
执行顺序:modifier 从左到右,body 在最后
核心术语
- storage:持久化存储,2^256 个 32 字节槽,SLOAD/SSTORE。
- memory:易失内存,交易结束销毁,MLOAD/MSSTORE。
- calldata:只读调用输入,CALLDATALOAD。
- mapping:键值映射,key → keccak256(key ++ slot) → 槽位。
- 可见性:external/public/internal/private,控制函数/变量的访问范围。
- modifier:函数修饰符,在函数执行前后插入逻辑。
- immutable:构造函数赋值,运行时不可变,存在字节码里。
- constant:编译时常量,存在字节码里。
- unchecked 块:0.8+ 关闭溢出检查的块。
覆盖范围
- 三种数据位置的区别与选择
- 值类型与引用类型
- mapping 的存储布局
- struct 与 array 的 packed 布局
- 可见性修饰符
- modifier 的执行顺序
- immutable 与 constant
- 0.8.x 溢出检查与 unchecked 块
高频题速览
| 编号 | 题目 | 难度 | 频率 |
|---|---|---|---|
| 15.4.1-001 | storage、memory、calldata 有什么区别? | 基础 | ★★★★★ |
| 15.4.1-002 | 值类型和引用类型有什么区别? | 基础 | ★★★★ |
| 15.4.1-003 | external、public、internal、private 有什么区别? | 基础 | ★★★★★ |
| 15.4.1-004 | mapping 的存储布局是怎样的? | 进阶 | ★★★★★ |
| 15.4.1-005 | struct 和 array 的 packed 布局是什么? | 进阶 | ★★★★ |
| 15.4.1-006 | modifier 的执行顺序是什么? | 进阶 | ★★★★ |
| 15.4.1-007 | immutable 和 constant 有什么区别? | 进阶 | ★★★★ |
| 15.4.1-008 | 0.8.x 的溢出检查是什么?什么时候用 unchecked? | 高级 | ★★★★ |
| 15.4.1-009 | 自定义 error 为什么省 Gas? | 高级 | ★★★★ |
| 15.4.1-010 | 函数指针怎么用? | 高级 | ★★★ |
15.4.1-001 storage、memory、calldata 有什么区别?
一句话结论
storage 是持久化存储(2^256 槽,SLOAD/SSTORE,贵),memory 是易失内存(交易结束销毁,MLOAD/MSSTORE,中等),calldata 是只读调用输入(CALLDATALOAD,便宜)。external 函数用 calldata 参数(省 Gas),internal 函数用 memory,持久状态用 storage。
概念解释
- storage:持久化,跨交易保留,SLOAD/SSTORE,贵(SLOAD 约 100 Gas,SSTORE 约 2 万 Gas)。
- memory:易失,交易结束销毁,MLOAD/MSSTORE,中等(约 3 Gas + 扩展费)。
- calldata:只读,调用输入,CALLDATALOAD,便宜(约 3 Gas)。
- 选择:external 函数参数用 calldata,internal 函数用 memory,持久状态用 storage。
原理流程
- 合约变量声明:
uint public x;默认 storage,持久化。 - 函数参数:
function f(uint calldata data) external;calldata 只读,省 Gas。 - 函数内临时变量:
uint memory y = ...;memory,交易结束销毁。 - 要修改数据:从 calldata 拷贝到 memory,再操作。
- 持久状态:写 storage,SSTORE。
代码或图示
contract C {
uint public x; // storage,持久化
// external 函数:参数用 calldata(只读,省 Gas)
function f(uint[] calldata data) external view returns (uint) {
// data 是 calldata,只读
uint sum = 0;
for (uint i = 0; i < data.length; i++) {
sum += data[i];
}
return sum;
}
// internal 函数:参数用 memory
function g(uint[] memory data) internal pure returns (uint) {
return data.length;
}
// 函数内临时变量:memory
function h() external pure returns (uint) {
uint memory y = 42; // memory,交易结束销毁
return y;
}
}
常见误区
- 误区:calldata 就是 memory 的只读版;正解:calldata 是调用方直接传进来的字节流,不需要 EVM 再拷贝,因此更便宜。
- 误区:所有变量都是 storage;正解:函数参数与临时变量默认 memory(或 calldata for external)。
- 误区:memory 变量持久化;正解:memory 交易结束销毁。
追问
- 为什么 external 函数用 calldata 更便宜?答:因为 calldata 直接引用调用方传进来的数据,不需要 EVM 再拷贝到 memory;memory 参数要先从 calldata 拷贝。机制上 calldata 是零拷贝。边界在于:如果函数要修改数据,必须用 memory。延伸:这是 15.4.4 Gas 优化的重点。
- 什么时候用 memory?答:当函数要修改数据、或 internal 函数要接收数组参数时。机制上 memory 是可读写的临时存储。边界在于:memory 比 calldata 贵(要拷贝)。延伸:这是 Solidity 数据位置的选择。
- storage 变量默认是 storage 吗?答:是的,合约级变量默认 storage;函数内变量默认 memory(值类型)或要显式声明(引用类型)。机制上 Solidity 编译器根据上下文推断数据位置。边界在于:引用类型(struct/array)在函数内要显式声明 memory。延伸:这是 Solidity 语法的基础。
15.4.1-002 值类型和引用类型有什么区别?
一句话结论
值类型(uint、int、address、bool、bytesNN、枚举)直接存在槽位里,拷贝时复制值;引用类型(struct、array、mapping、string)存在槽位里的是指针或槽位号,拷贝时复制引用(不复制数据)。
概念解释
- 值类型:uint、int、address、bool、bytesNN(固定长度字节)、枚举;直接存在槽位里。
- 引用类型:struct、array、mapping、string(动态长度);存在槽位里的是指针或槽位号。
- 拷贝语义:值类型拷贝时复制值;引用类型拷贝时复制引用(不复制数据)。
- 栈 vs 堆:类似其他语言的值类型在栈、引用类型在堆。
原理流程
- 值类型变量:
uint x = 42;直接存在槽位里。 - 引用类型变量:
uint[] memory arr;存在槽位里的是指针(指向内存位置)。 - 值类型拷贝:
uint y = x;复制值,y 是独立的。 - 引用类型拷贝:
uint[] memory arr2 = arr;复制引用,arr2 与 arr 指向同一块内存。 - 修改 arr2 会影响 arr(因为指向同一块内存)。
代码或图示
contract C {
// 值类型
uint public x = 42;
function f() public view {
uint y = x; // 值类型拷贝:复制值
y = 100; // 修改 y,不影响 x
}
// 引用类型
function g() public pure {
uint[] memory arr = new uint[](3);
arr[0] = 1;
uint[] memory arr2 = arr; // 引用拷贝:arr2 与 arr 指向同一块内存
arr2[0] = 2; // 修改 arr2[0],也影响 arr[0]
}
}
常见误区
- 误区:引用类型拷贝会复制数据;正解:引用类型拷贝只复制引用,不复制数据。
- 误区:所有类型都是值类型;正解:struct、array、mapping、string 是引用类型。
- 误区:storage 与 memory 的拷贝一样;正解:storage 引用类型拷贝是按槽位拷贝,memory 是按指针。
追问
- 为什么引用类型拷贝不复制数据?答:因为复制大数据(如大数组)很贵,引用拷贝只复制指针。机制上这是性能优化。边界在于:这也意味着修改引用会影响原变量。延伸:这是 Solidity 语义的重要点。
- storage 引用类型拷贝是什么?答:
uint[] storage arr2 = arr;arr2 与 arr 指向同一个 storage 槽位,修改 arr2 影响 arr。机制上 storage 引用拷贝是别名。边界在于:这也是为什么 storage 变量要小心别名。延伸:这是 Solidity 语义的重点。 - 怎么深拷贝引用类型?答:手动遍历复制,或用 memory 拷贝构造。机制上 Solidity 没有内置深拷贝。边界在于:深拷贝很贵(要逐元素复制)。延伸:这是性能与正确性的权衡。
15.4.1-003 external、public、internal、private 有什么区别?
一句话结论
external 只能外部调用,public 外部+内部都能调,internal 只内部(合约与子类),private 只本合约。public 变量自动生成 getter 函数。
概念解释
- external:只能外部调用(EOA 或其他合约),不能内部直接调用。
- public:外部+内部都能调;public 变量自动生成 getter。
- internal:只内部(合约与子类),外部不能调。
- private:只本合约,子类也不能调。
原理流程
- external 函数:只能从外部调用,内部要用
this.f()调用(会触发外部调用)。 - public 函数:外部+内部都能调。
- internal 函数:只合约与子类能调。
- private 函数:只本合约能调。
- public 变量:自动生成 getter 函数(如
uint public x;自动有x()函数)。
代码或图示
contract C {
uint public x = 42; // public 变量:自动生成 getter x()
function externalFunc() external pure returns (uint) {
return 1;
}
function publicFunc() public pure returns (uint) {
return 2;
}
function internalFunc() internal pure returns (uint) {
return 3;
}
function privateFunc() private pure returns (uint) {
return 4;
}
function test() public view {
// externalFunc(); // 错误:不能直接调用 external
this.externalFunc(); // OK:用 this. 调用
publicFunc(); // OK
internalFunc(); // OK
privateFunc(); // OK
}
}
contract D is C {
function test2() public view {
// externalFunc(); // 错误
publicFunc(); // OK
internalFunc(); // OK(internal 子类可访问)
// privateFunc(); // 错误(private 子类不可访问)
}
}
常见误区
- 误区:external 就是 public;正解:external 只能外部调用,内部不能直接调。
- 误区:private 子类也能访问;正解:private 只本合约,子类不能访问。
- 误区:public 变量自动生成 setter;正解:只生成 getter,不生成 setter。
追问
- 为什么 external 比 public 省 Gas?答:因为 external 函数参数用 calldata(只读,零拷贝);public 函数参数用 memory(要从 calldata 拷贝)。机制上 external 可以直接引用 calldata。边界在于:external 函数不能内部直接调用。延伸:这是 15.4.4 Gas 优化的重点。
- public 变量自动生成什么?答:自动生成 getter 函数,返回变量值;不生成 setter(变量是只读的)。机制上编译器自动生成 getter。边界在于:public 数组变量只生成索引 getter(
arr(uint index)),不生成整个数组 getter。延伸:这是 Solidity 的语法糖。 - internal 与 private 的区别?答:internal 子类可以访问,private 子类不能访问。机制上 internal 是"家族可见",private 是"只本合约"。边界在于:private 不是安全边界(字节码里函数仍然存在)。延伸:这是 Solidity 可见性的语义。
15.4.1-004 mapping 的存储布局是怎样的?
一句话结论
mapping 的存储布局:key → keccak256(key ++ slot) → 槽位;不存在的 key 查出来 = 0。mapping 不存长度,也不存所有 key,只能按键查询。
概念解释
- mapping:
mapping(address => uint) public balances;key 是 address,value 是 uint。 - 存储布局:key → keccak256(abi.encode(key, slot)) → 槽位。
- slot:mapping 变量所在的槽位(如 slot 0)。
- 不存在的 key:查出来 = 0(因为槽位未写过,SLOAD 默认返回 0)。
原理流程
- 声明 mapping:
mapping(address => uint) public balances;存在 slot 0。 - 查
balances[alice]:计算槽位 = keccak256(abi.encode(alice, 0))。 - SLOAD 该槽位:如果未写过,返回 0。
- 写
balances[alice] = 100:SSTORE 该槽位 = 100。 - mapping 不存长度,也不存所有 key,只能按键查询。
代码或图示
mapping 存储布局:
声明:mapping(address => uint) public balances; // slot 0
查 balances[alice]:
槽位 = keccak256(abi.encode(alice, 0))
SLOAD 槽位 → 如果未写过,返回 0
写 balances[alice] = 100:
槽位 = keccak256(abi.encode(alice, 0))
SSTORE 槽位 = 100
特点:
不存长度,不存所有 key
只能按键查询
不存在的 key 查出来 = 0
常见误区
- 误区:mapping 存所有 key;正解:mapping 不存 key,只能按键查询。
- 误区:mapping 有长度;正解:mapping 没有 length 属性。
- 误区:mapping 的 key 是普通槽位;正解:key → keccak256(key ++ slot) → 槽位。
追问
- 怎么遍历 mapping?答:不能直接遍历,因为 mapping 不存所有 key;要自己维护一个 key 数组。机制上 mapping 是稀疏键值表,不支持遍历。边界在于:这也是为什么常见模式是
mapping(address => uint) public balances; address[] public holders;。延伸:这是 Solidity 数据结构的取舍。 - 嵌套 mapping 怎么布局?答:
mapping(address => mapping(address => uint)) public allowances;槽位 = keccak256(abi.encode(key2, keccak256(abi.encode(key1, slot))))。机制上嵌套 mapping 是两次 keccak256。边界在于:嵌套越深,计算越复杂。延伸:这是 ERC20 allowance 的实现。 - mapping 与数组的区别?答:mapping 是稀疏键值表(O(1) 按键查询,不存长度),数组是连续列表(O(1) 索引访问,有 length)。机制上两者用途不同:mapping 用于键值映射,数组用于有序列表。边界在于:mapping 不支持遍历,数组支持。延伸:这是 Solidity 数据结构的选择。
15.4.1-005 struct 和 array 的 packed 布局是什么?
一句话结论
Solidity 把相邻的值类型变量打包到一个 32 字节槽位(packed storage):如果相邻变量加起来不超过 32 字节,就放在同一个槽位里。这样节省 SSTORE 成本。
概念解释
- packed storage:相邻小变量打包到一个 32 字节槽位。
- 例:uint128 + uint128 = 32 字节,放在一个槽位。
- 不打包:如果下一个变量放不下,就放到下一个槽位。
- 目的:节省 SSTORE 成本(一个槽位的 SSTORE 成本与变量数无关)。
原理流程
- 声明变量:
uint128 a; uint128 b;a 在 slot 0 的前 16 字节,b 在 slot 0 的后 16 字节。 - 如果下一个变量
uint256 c;放不下(slot 0 已满),c 放到 slot 1。 - 修改 a 或 b 时,SSTORE 整个 slot 0(包含 a 和 b)。
- 目的:节省 SSTORE 成本(一个槽位只付一次钱)。
- 注意:mapping 与动态数组不打包(因为它们的槽位是 keccak256 计算的)。
代码或图示
packed storage 示例:
contract C {
uint128 public a; // slot 0 前 16 字节
uint128 public b; // slot 0 后 16 字节
uint256 public c; // slot 1(放不下,放新槽位)
}
槽位布局:
slot 0: [a(16 字节)][b(16 字节)] = 32 字节
slot 1: [c(32 字节)]
修改 a:
SSTORE slot 0(包含 a 和 b)
→ 一次 SSTORE,两个变量
注意:
mapping 与动态数组不打包(它们的槽位是 keccak256 计算的)
常见误区
- 误区:所有变量都占一个槽位;正解:相邻小变量打包到一个槽位。
- 误区:packed storage 影响访问;正解:Solidity 编译器自动处理,开发者透明。
- 误区:mapping 也打包;正解:mapping 不打包(槽位是 keccak256 计算的)。
追问
- 为什么 packed storage 能省 Gas?答:因为一个槽位的 SSTORE 成本与变量数无关——把两个 uint128 打包到一个槽位,只付一次 SSTORE 成本。机制上 SSTORE 是按槽位计费。边界在于:packed 只对小变量有效(加起来不超过 32 字节)。延伸:这是 15.4.4 Gas 优化的重点。
- 怎么利用 packed storage?答:把小变量(uint128、uint64、address)相邻声明,让它们打包到一个槽位。机制上 Solidity 自动打包相邻小变量。边界在于:变量顺序影响打包(要把小变量放一起)。延伸:这是合约设计的优化。
- packed storage 与升级代理有什么关系?答:升级代理时,变量顺序不能变(否则 packed 布局会错位);这也是
__gap的原因。机制上 packed 布局依赖变量顺序。边界在于:升级时要保持变量顺序。延伸:这是 15.4.2 的主题。
15.4.1-006 modifier 的执行顺序是什么?
一句话结论
modifier 从左到右执行,函数 body 在最后;每个 modifier 用 _; 表示"继续执行下一个 modifier 或 body"。
概念解释
- modifier:函数修饰符,在函数执行前后插入逻辑。
- 执行顺序:从左到右,body 在最后。
_;:表示"继续执行下一个 modifier 或 body"。- 参数:modifier 可以带参数。
原理流程
- 定义 modifier:
modifier onlyOwner { require(msg.sender == owner); _; } - 用 modifier:
function f() public onlyOwner { ... } - 执行顺序:require(...) →
_;→ body。 - 多个 modifier:
function f() public onlyOwner whenNotPaused { ... }顺序:onlyOwner → whenNotPaused → body。 - modifier 带参数:
modifier cost(uint amount) { require(msg.value >= amount); _; }
代码或图示
contract C {
address public owner;
bool public paused;
modifier onlyOwner() {
require(msg.sender == owner, "not owner");
_; // 继续执行下一个 modifier 或 body
}
modifier whenNotPaused() {
require(!paused, "paused");
_;
}
function f() public onlyOwner whenNotPaused {
// body
}
// 执行顺序:
// 1. require(msg.sender == owner)
// 2. require(!paused)
// 3. body
}
常见误区
- 误区:modifier 从右到左执行;正解:从左到右执行,body 在最后。
- 误区:
_;是结束;正解:_;是"继续执行下一个 modifier 或 body"。 - 误区:modifier 不能带参数;正解:modifier 可以带参数。
追问
- modifier 里的
_;可以放多次吗?答:可以,这是"循环执行"模式;但常见用法是放一次。机制上_;表示"继续执行",放多次会重复执行 body。边界在于:这是高级用法,容易出错。延伸:这是 Solidity 的高级特性。 - modifier 与继承的关系?答:modifier 可以被继承,子类可以覆写(virtual + override)。机制上 modifier 是合约的成员,可以继承。边界在于:覆写 modifier 要小心执行顺序。延伸:这是 15.4.2 的主题。
- modifier 与 require 的区别?答:modifier 是可复用的前置/后置逻辑,require 是单个检查。机制上 modifier 可以封装多个检查与逻辑。边界在于:modifier 让代码更简洁。延伸:这是 Solidity 的代码组织。
15.4.1-007 immutable 和 constant 有什么区别?
一句话结论
constant 是编译时常量(在源码里写死),immutable 是构造函数赋值(部署时确定,运行时不可变)。两者都存在字节码里,不占 storage 槽位。
概念解释
- constant:编译时常量,在源码里写死(如
uint constant X = 42;)。 - immutable:构造函数赋值,部署时确定(如
uint immutable public Y;)。 - 存储位置:两者都存在字节码里,不占 storage 槽位。
- Gas 成本:比 storage 便宜(不用 SLOAD)。
原理流程
- constant:
uint constant X = 42;编译时确定,存在字节码里。 - immutable:
uint immutable public Y;构造函数里赋值Y = 100;,部署时确定。 - 访问时:直接从字节码里读(PUSH32 操作码),不用 SLOAD。
- 不占 storage 槽位,省 Gas。
- 区别:constant 编译时确定,immutable 部署时确定。
代码或图示
contract C {
uint public constant X = 42; // 编译时常量
uint public immutable Y; // 构造函数赋值
constructor(uint y) {
Y = y; // 部署时确定
}
}
// 访问:
// C.X() → 42(从字节码读,不用 SLOAD)
// C.Y() → 部署时传入的值(从字节码读,不用 SLOAD)
常见误区
- 误区:immutable 与 constant 一样;正解:constant 编译时确定,immutable 部署时确定。
- 误区:immutable 占 storage 槽位;正解:两者都存在字节码里,不占槽位。
- 误区:immutable 可以在运行时修改;正解:immutable 部署后不可变。
追问
- 为什么 immutable 比 storage 便宜?答:因为 immutable 存在字节码里,访问时用 PUSH32 操作码(约 3 Gas),不用 SLOAD(约 100 Gas)。机制上 immutable 是常量,不是存储。边界在于:immutable 部署时确定,不能在运行时修改。延伸:这是 15.4.4 Gas 优化的重点。
- 什么时候用 immutable?答:当值在部署时确定(如 owner 地址、合约地址)但不是编译时常量时。机制上 immutable 适合"部署时确定但运行时不可变"的值。边界在于:constant 适合编译时确定的值。延伸:这是合约设计的选择。
- immutable 与升级代理有什么关系?答:升级代理时,实现合约的 immutable 变量会存在代理的字节码里(不是实现合约的);这也是为什么代理模式要小心 immutable。机制上 immutable 存在字节码里,升级时代理的字节码不变。边界在于:这是代理模式的注意点。延伸:这是 15.4.2 的主题。
15.4.1-008 0.8.x 的溢出检查是什么?什么时候用 unchecked?
一句话结论
Solidity 0.8+ 默认对算术操作(+、-、*、/)做溢出检查,溢出时自动 revert;unchecked 块关闭检查,用于性能优化(确认不会溢出时)。
概念解释
- 0.8+ 溢出检查:默认对算术操作做溢出检查,溢出时 revert(Panic 错误码)。
- unchecked 块:关闭溢出检查,用于性能优化。
- 什么时候用 unchecked:确认不会溢出时(如递增计数器,模运算)。
- 风险:unchecked 时溢出会静默绕回,可能导致逻辑错误。
原理流程
- 0.8+ 默认:
uint a = 256; uint b = a + 1;溢出时 revert(因为 uint8 最大 255)。 - unchecked 块:
unchecked { uint b = a + 1; }不检查,溢出绕回。 - 什么时候用 unchecked:确认不会溢出时(如
i++在循环里,i 有上界)。 - 风险:unchecked 时溢出静默绕回,可能导致逻辑错误。
- Gas:unchecked 比 checked 便宜(不做检查)。
代码或图示
contract C {
// 0.8+ 默认:溢出检查
function f(uint8 a) public pure returns (uint8) {
return a + 1; // 如果 a = 255,溢出 revert
}
// unchecked 块:关闭检查
function g(uint8 a) public pure returns (uint8) {
unchecked {
return a + 1; // 如果 a = 255,溢出绕回 0,不 revert
}
}
// 循环里用 unchecked:i 有上界,不会溢出
function sum(uint n) public pure returns (uint) {
uint s = 0;
for (uint i = 0; i < n; i++) {
unchecked { s += i; } // i 有上界 n,不会溢出
}
return s;
}
}
常见误区
- 误区:0.8+ 不需要溢出检查;正解:0.8+ 默认检查,但 unchecked 块关闭。
- 误区:unchecked 总是安全;正解:unchecked 时溢出静默绕回,可能导致逻辑错误。
- 误区:unchecked 省 Gas 很多;正解:unchecked 省少量 Gas(不做检查)。
追问
- 0.8 之前怎么做溢出检查?答:用 SafeMath 库(如 OpenZeppelin 的 SafeMath),手动加检查。机制上 0.8 之前默认不检查,要手动加 SafeMath。边界在于:0.8 之后默认检查,SafeMath 不再需要。延伸:这是 Solidity 的演进。
- 什么时候用 unchecked?答:确认不会溢出时——如循环递增计数器(i 有上界)、模运算(已取模)、外部输入已验证。机制上 unchecked 省少量 Gas。边界在于:不确定时不要用 unchecked。延伸:这是性能与安全的权衡。
- unchecked 有什么风险?答:溢出静默绕回,可能导致逻辑错误(如余额计算错误)。机制上 unchecked 不检查,溢出绕回。边界在于:这是安全风险,要谨慎使用。延伸:这是 15.5 合约安全的重点。
15.4.1-009 自定义 error 为什么省 Gas?
一句话结论
自定义 error 省 Gas,因为它没有 Error(string) 的字符串长度与数据段开销;自定义 error 的参数直接编码,比 Error(string) 紧凑。
概念解释
- Error(string):selector + offset + 长度 + 字符串,开销大。
- 自定义 error:selector + 参数直接编码,紧凑。
- Gas 节省:自定义 error 比 Error(string) 便宜(几百到几千 Gas)。
- 例子:
error InsufficientBalance(uint256 required, uint256 available);
原理流程
- Error(string):selector + offset + 长度 + 字符串(动态类型,开销大)。
- 自定义 error:selector + 参数直接编码(静态类型,紧凑)。
- 节省:自定义 error 没有 offset、长度、字符串数据段,省几百到几千 Gas。
- 用法:
revert InsufficientBalance(required, available); - try/catch 可以捕获自定义 error。
代码或图示
// Error(string):开销大
function withdraw(uint amount) external {
require(amount <= balances[msg.sender], "insufficient balance");
// 数据 = Error selector + offset + 长度 + "insufficient balance"
}
// 自定义 error:紧凑
error InsufficientBalance(uint256 required, uint256 available);
function withdraw2(uint amount) external {
if (amount > balances[msg.sender]) {
revert InsufficientBalance(amount, balances[msg.sender]);
}
// 数据 = 自定义 selector + required + available(紧凑)
}
常见误区
- 误区:自定义 error 与 Error(string) 一样;正解:自定义 error 省 Gas(没有字符串开销)。
- 误区:自定义 error 是 0.8+ 才有;正解:是的,0.8+ 引入自定义 error。
- 误区:try/catch 不能捕获自定义 error;正解:try/catch 可以捕获自定义 error。
追问
- 自定义 error 省多少 Gas?答:省几百到几千 Gas(取决于字符串长度);短字符串省几百,长字符串省几千。机制上 Error(string) 有 offset、长度、字符串数据段。边界在于:自定义 error 错误信息是结构化的(不是人类可读字符串)。延伸:这是 15.4.4 Gas 优化的重点。
- 怎么用 try/catch 捕获自定义 error?答:
try externalCall(...) returns (...) { } catch InsufficientBalance(uint required, uint available) { }。机制上 try/catch 按 selector 匹配 error。边界在于:要知道自定义 error 的签名。延伸:这是 Solidity 0.8+ 的错误处理。 - 自定义 error 与事件有什么区别?答:error 是 revert 时抛出的错误,事件是正常执行时记录的日志。机制上 error 中断执行,事件记录状态。边界在于:error 用于错误处理,事件用于 DApp 监听。延伸:这是 Solidity 的语义。
15.4.1-010 函数指针怎么用?
一句话结论
Solidity 可以把函数赋值给函数指针,类型是 function(参数类型) 返回类型;用于回调、策略模式等场景。
概念解释
- 函数指针:
function(uint) external returns (uint)类型的变量。 - 用途:回调、策略模式、委托。
- 调用:像普通函数一样调用。
- 注意:函数指针是 external 或 internal。
原理流程
- 定义函数指针类型:
type Fn = function(uint) external returns (uint); - 赋值:
Fn fn = target.calculate; - 调用:
uint result = fn(42); - 用途:回调(把函数传给另一个合约)、策略模式(动态选择算法)。
- 注意:external 函数指针包含地址 + selector。
代码或图示
contract Callee {
function calculate(uint x) external pure returns (uint) {
return x * 2;
}
}
contract Caller {
// external 函数指针
function calculate(address callee, uint x) external returns (uint) {
function(uint) external returns (uint) fn = Callee(callee).calculate;
return fn(x); // 调用函数指针
}
}
常见误区
- 误区:函数指针就是函数名;正解:函数指针是类型化的变量,可以赋值。
- 误区:internal 函数指针包含地址;正解:internal 函数指针只是内部函数引用,external 函数指针包含地址 + selector。
- 误区:函数指针不能用于回调;正解:函数指针常用于回调。
追问
- 函数指针有什么用?答:用于回调(把函数传给另一个合约,让它执行完后回调)、策略模式(动态选择算法)。机制上函数指针是一等公民。边界在于:external 函数指针包含地址 + selector,调用是外部调用。延伸:这是 Solidity 的高级特性。
- internal 与 external 函数指针的区别?答:internal 函数指针只是内部函数引用(不包含地址),external 函数指针包含地址 + selector。机制上 internal 是内部调用,external 是外部调用。边界在于:internal 函数指针不能跨合约传递。延伸:这是 Solidity 的语义。
- 函数指针有什么安全风险?答:如果传入恶意合约地址,函数指针会调用恶意合约的函数,可能导致重入或状态不一致。机制上函数指针是外部调用,要信任目标合约。边界在于:这是合约安全的重点。延伸:这是 15.5 合约安全的主题。
动手练习
练习 1:写一个带 mapping 与 packed storage 的合约
- 任务:写一个 ERC20 合约,用 mapping 存余额、用 packed storage 优化;测试 Gas 消耗。
- 验收标准:
- 能写出 mapping 布局。
- 能利用 packed storage 优化。
- 能测试不同变量顺序的 Gas 差异。
练习 2:用自定义 error 优化合约
- 任务:把 require("...") 改成自定义 error,测试 Gas 节省。
- 验收标准:
- 能写出自定义 error 定义。
- 能测试 Gas 节省。
- 能写出 try/catch 捕获自定义 error。
自检清单
- [ ] 能区分 storage/memory/calldata 的区别与选择?
- [ ] 能区分值类型与引用类型?
- [ ] 能解释四种可见性修饰符?
- [ ] 能画出 mapping 的存储布局?
- [ ] 能解释 packed storage 的原理?
- [ ] 能说明 modifier 的执行顺序?
- [ ] 能区分 immutable 与 constant?
- [ ] 能解释 0.8+ 溢出检查与 unchecked 块?
- [ ] 能说明自定义 error 为什么省 Gas?
- [ ] 能使用函数指针?
延伸阅读
- Solidity 官方文档:Types、Data Locations、Visibility、Function Modifiers。
- OpenZeppelin Contracts:SafeMath、Ownable、Pausable。
- Solidity 0.8 发布说明:溢出检查、自定义 error。
- 《Solidity by Example》:数据位置、可见性。
待整理清单
- [ ] 补充 Solidity 最新版本的新特性(待确认)
- [ ] 补充 packed storage 的实际 Gas 节省数据
- [ ] 补充函数指针的安全最佳实践