罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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 块。

先修与前置

知识地图

数据位置:
  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。

原理流程

  1. 合约变量声明:uint public x; 默认 storage,持久化。
  2. 函数参数:function f(uint calldata data) external; calldata 只读,省 Gas。
  3. 函数内临时变量:uint memory y = ...; memory,交易结束销毁。
  4. 要修改数据:从 calldata 拷贝到 memory,再操作。
  5. 持久状态:写 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 堆:类似其他语言的值类型在栈、引用类型在堆。

原理流程

  1. 值类型变量:uint x = 42; 直接存在槽位里。
  2. 引用类型变量:uint[] memory arr; 存在槽位里的是指针(指向内存位置)。
  3. 值类型拷贝:uint y = x; 复制值,y 是独立的。
  4. 引用类型拷贝:uint[] memory arr2 = arr; 复制引用,arr2 与 arr 指向同一块内存。
  5. 修改 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:只本合约,子类也不能调。

原理流程

  1. external 函数:只能从外部调用,内部要用 this.f() 调用(会触发外部调用)。
  2. public 函数:外部+内部都能调。
  3. internal 函数:只合约与子类能调。
  4. private 函数:只本合约能调。
  5. 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)。

原理流程

  1. 声明 mapping:mapping(address => uint) public balances; 存在 slot 0。
  2. 查 balances[alice]:计算槽位 = keccak256(abi.encode(alice, 0))。
  3. SLOAD 该槽位:如果未写过,返回 0。
  4. 写 balances[alice] = 100:SSTORE 该槽位 = 100。
  5. 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 成本与变量数无关)。

原理流程

  1. 声明变量:uint128 a; uint128 b; a 在 slot 0 的前 16 字节,b 在 slot 0 的后 16 字节。
  2. 如果下一个变量 uint256 c; 放不下(slot 0 已满),c 放到 slot 1。
  3. 修改 a 或 b 时,SSTORE 整个 slot 0(包含 a 和 b)。
  4. 目的:节省 SSTORE 成本(一个槽位只付一次钱)。
  5. 注意: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 可以带参数。

原理流程

  1. 定义 modifier:modifier onlyOwner { require(msg.sender == owner); _; }
  2. 用 modifier:function f() public onlyOwner { ... }
  3. 执行顺序:require(...) → _; → body。
  4. 多个 modifier:function f() public onlyOwner whenNotPaused { ... } 顺序:onlyOwner → whenNotPaused → body。
  5. 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)。

原理流程

  1. constant:uint constant X = 42; 编译时确定,存在字节码里。
  2. immutable:uint immutable public Y; 构造函数里赋值 Y = 100;,部署时确定。
  3. 访问时:直接从字节码里读(PUSH32 操作码),不用 SLOAD。
  4. 不占 storage 槽位,省 Gas。
  5. 区别: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 时溢出会静默绕回,可能导致逻辑错误。

原理流程

  1. 0.8+ 默认:uint a = 256; uint b = a + 1; 溢出时 revert(因为 uint8 最大 255)。
  2. unchecked 块:unchecked { uint b = a + 1; } 不检查,溢出绕回。
  3. 什么时候用 unchecked:确认不会溢出时(如 i++ 在循环里,i 有上界)。
  4. 风险:unchecked 时溢出静默绕回,可能导致逻辑错误。
  5. 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);

原理流程

  1. Error(string):selector + offset + 长度 + 字符串(动态类型,开销大)。
  2. 自定义 error:selector + 参数直接编码(静态类型,紧凑)。
  3. 节省:自定义 error 没有 offset、长度、字符串数据段,省几百到几千 Gas。
  4. 用法:revert InsufficientBalance(required, available);
  5. 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。

原理流程

  1. 定义函数指针类型:type Fn = function(uint) external returns (uint);
  2. 赋值:Fn fn = target.calculate;
  3. 调用:uint result = fn(42);
  4. 用途:回调(把函数传给另一个合约)、策略模式(动态选择算法)。
  5. 注意: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 消耗。
  • 验收标准:
    1. 能写出 mapping 布局。
    2. 能利用 packed storage 优化。
    3. 能测试不同变量顺序的 Gas 差异。

练习 2:用自定义 error 优化合约

  • 任务:把 require("...") 改成自定义 error,测试 Gas 节省。
  • 验收标准:
    1. 能写出自定义 error 定义。
    2. 能测试 Gas 节省。
    3. 能写出 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 节省数据
  • [ ] 补充函数指针的安全最佳实践