Effective C++ 条款33：避免遮掩继承而来的名字

最新推荐文章于 2026-06-30 09:06:16 发布
原创 最新推荐文章于 2026-06-30 09:06:16 发布 · 181 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Effective C++

当前文章被收录于：

Effective C++
50 篇文章 0 人学习

Effective C++，改善程序与设计的55个具体做法，让你的C++写的更高效，是学习C++的必看经典作品

订阅专栏 查看详情

Effective C++ 条款33：避免遮掩继承而来的名字

在 C++ 的继承体系中，你是否遇到过"明明基类有这个方法，为什么编译器说找不到"的困惑？
这很可能是名字遮掩（name hiding）在作祟。本条款将揭开这个隐秘陷阱的面纱。

一、问题引入：消失的基类成员

先看一个令人困惑的例子：

#include <iostream>
#include <string>

class Base {
public:
    void mf1() {
        std::cout << "Base::mf1()\n";
    }
    
    void mf1(int x) {
        std::cout << "Base::mf1(int): " << x << "\n";
    }
    
    void mf2() {
        std::cout << "Base::mf2()\n";
    }
    
    void mf3() {
        std::cout << "Base::mf3()\n";
    }
    
    void mf3(double x) {
        std::cout << "Base::mf3(double): " << x << "\n";
    }
};

class Derived : public Base {
public:
    void mf1() {  // 注意：这里只声明了 mf1()，没有参数版本
        std::cout << "Derived::mf1()\n";
    }
    
    void mf3() {  // 同样只声明了 mf3()
        std::cout << "Derived::mf3()\n";
    }
};

int main() {
    Derived d;
    
    d.mf1();       // OK: 调用 Derived::mf1()
    // d.mf1(10);  // 编译错误！Base::mf1(int) 被遮掩了！
    
    d.mf2();       // OK: 调用 Base::mf2()
    
    d.mf3();       // OK: 调用 Derived::mf3()
    // d.mf3(3.14); // 编译错误！Base::mf3(double) 也被遮掩了！
}

奇怪的现象： Derived 明明 public 继承了 Base，但 Base::mf1(int) 和 Base::mf3(double) 却无法通过 Derived 对象访问！

二、名字遮掩的原理

2.1 C++ 的名字查找规则

要理解这个问题，我们需要了解 C++ 的**名字查找（name lookup）**机制：

C++ 的名字查找规则：只隐藏名字（hiding names），与类型无关。

当编译器遇到一个名字时，它会按照以下顺序查找：

  1. 局部作用域（当前函数体内）
  2. 包含作用域（当前类的成员）
  3. 下一个包含作用域（基类的成员）
  4. 命名空间作用域

关键规则： 一旦在某个作用域中找到了匹配的名字，查找就会停止，不会再继续搜索外层作用域中的同名标识符。

int x = 10;  // 全局变量

void someFunc() {
    double x = 3.14;  // 局部变量，名字与全局变量相同
    
    std::cout << x;  // 输出 3.14，全局的 int x 被"遮掩"了
    // 编译器在局部作用域找到了 x，就不再查找全局的 x
}

2.2 继承中的名字遮掩

在继承体系中，这个规则同样适用：

class Base {
public:
    void mf1();       // 版本1
    void mf1(int);    // 版本2（重载）
    void mf1(double); // 版本3（重载）
};

class Derived : public Base {
public:
    void mf1();       // 派生类中声明了同名函数
    // 结果：Base 中所有名为 mf1 的函数都被遮掩了！
    // 包括 mf1()、mf1(int)、mf1(double)
};
现象说明
名字相同即遮掩不需要参数列表相同，甚至不需要是函数
全部重载版本被遮掩派生类中一个同名函数会遮掩基类中所有同名函数
与 virtual 无关即使是 non-virtual 函数也会发生遮掩
与访问权限无关private 成员也会参与名字查找并导致遮掩

2.3 变量和类型也会被遮掩

class Base {
public:
    int x = 10;
    enum Color { Red, Green, Blue };
    typedef int Integer;
    
    void func(int) {}
};

class Derived : public Base {
public:
    double x = 3.14;        // 遮掩了 Base::x
    enum Color { Cyan };     // 遮掩了 Base::Color
    typedef double Integer;  // 遮掩了 Base::Integer
    
    void func(double) {}     // 遮掩了 Base::func(int)
};

int main() {
    Derived d;
    std::cout << d.x;        // 输出 3.14，Base::x 被遮掩
    // d.func(10);           // 错误！Base::func(int) 被遮掩
}

三、为什么 C++ 要这样设计？

你可能会问：为什么 C++ 不设计成"只遮掩参数完全相同的函数，保留重载版本"？

原因：防止意外的行为变化。

// 假设你开发了一个库
class LibraryBase {
public:
    void process(int x) { /* ... */ }
};

// 用户继承你的类
class UserDerived : public LibraryBase {
public:
    void process(const std::string& s) { /* ... */ }
    // 用户只关心处理字符串
};

// 后来库升级，LibraryBase 新增了一个重载：
class LibraryBase {
public:
    void process(int x) { /* ... */ }
    void process(double x) { /* 新增！ */ }  // 如果 C++ 不遮掩，
                                              // 这会突然在 UserDerived 中可用！
};

如果 C++ 不采用"名字级别"的遮掩，那么库的作者新增一个重载函数，可能会意外地改变派生类的行为。这种设计确保了派生类对继承来的名字有完全的控制权。

四、解决方案：让被遮掩的名字重见天日

4.1 方案一：using 声明式（推荐用于 public 继承）

using 声明式可以将基类中的名字引入到派生类的作用域中：

class Base {
public:
    void mf1() {
        std::cout << "Base::mf1()\n";
    }
    
    void mf1(int x) {
        std::cout << "Base::mf1(int): " << x << "\n";
    }
    
    void mf1(double x) {
        std::cout << "Base::mf1(double): " << x << "\n";
    }
    
    void mf2() {
        std::cout << "Base::mf2()\n";
    }
};

class Derived : public Base {
public:
    // 使用 using 声明，将 Base 中所有名为 mf1 的成员引入 Derived 作用域
    using Base::mf1;
    using Base::mf2;
    
    void mf1() {  // 现在这是重载，不是遮掩！
        std::cout << "Derived::mf1()\n";
    }
    
    void mf3() {
        std::cout << "Derived::mf3()\n";
    }
};

int main() {
    Derived d;
    
    d.mf1();        // OK: 调用 Derived::mf1()
    d.mf1(10);      // OK: 调用 Base::mf1(int)
    d.mf1(3.14);    // OK: 调用 Base::mf1(double)
    d.mf2();        // OK: 调用 Base::mf2()
    
    return 0;
}

using 声明的作用：

特性说明
引入所有重载using Base::mf1 引入 Base 中所有名为 mf1 的函数
保持访问权限在 public 区域 using，引入的就是 public 成员
可配合重载派生类可以声明自己的重载版本，与引入的版本共存
适用于变量/类型也可以用于引入基类的成员变量、嵌套类型等

4.2 方案二：转交函数（Forwarding Functions）

如果你只想暴露基类的部分重载版本，或者需要在 private 继承中暴露特定接口，可以使用转交函数：

class Base {
public:
    void mf1() {
        std::cout << "Base::mf1()\n";
    }
    
    void mf1(int x) {
        std::cout << "Base::mf1(int): " << x << "\n";
    }
    
    void mf1(double x) {
        std::cout << "Base::mf1(double): " << x << "\n";
    }
};

class Derived : public Base {
public:
    void mf1() {  // 派生类自己的版本
        std::cout << "Derived::mf1()\n";
    }
    
    // 转交函数：只暴露 Base::mf1(int)，不暴露 mf1(double)
    void mf1(int x) {
        std::cout << "[Derived forwarding] ";
        Base::mf1(x);  // 显式调用基类版本
    }
    
    // 注意：Base::mf1(double) 仍然被遮掩，无法通过 Derived 访问
};

int main() {
    Derived d;
    
    d.mf1();      // OK: Derived::mf1()
    d.mf1(10);    // OK: 通过转交函数调用 Base::mf1(int)
    // d.mf1(3.14); // 错误：Base::mf1(double) 仍然被遮掩
}

转交函数的优势：

场景使用转交函数
选择性暴露只暴露基类的部分重载版本
添加前置/后置逻辑在调用基类前后添加日志、校验等
private 继承将基类接口包装后暴露为 public
改变参数对参数进行转换后再转发给基类

4.3 两种方案的对比

特性using 声明转交函数
代码量少（一行）多（每个函数都要写）
灵活性引入所有重载可精确控制引入哪些
可扩展性基类新增重载自动可用需要手动添加转交函数
可添加逻辑否是
适用场景public 继承，需要全部重载private 继承，或需要包装

五、实际应用场景

场景1：GUI 框架中的事件处理

class Widget {
public:
    // 多种事件处理重载
    virtual void onEvent(const MouseEvent& e) {
        std::cout << "Widget 处理鼠标事件\n";
    }
    
    virtual void onEvent(const KeyEvent& e) {
        std::cout << "Widget 处理键盘事件\n";
    }
    
    virtual void onEvent(const ResizeEvent& e) {
        std::cout << "Widget 处理尺寸变化事件\n";
    }
};

class Button : public Widget {
public:
    // 如果不使用 using，下面这个声明会遮掩 Widget 中所有 onEvent 重载！
    void onEvent(const MouseEvent& e) override {
        std::cout << "Button 处理鼠标点击\n";
        // 用户可能还想处理键盘事件（比如空格键触发按钮）
        // 但 Widget::onEvent(KeyEvent) 已经被遮掩了！
    }
};

// 正确的做法
class Button : public Widget {
public:
    using Widget::onEvent;  // 引入基类的所有事件处理
    
    void onEvent(const MouseEvent& e) override {
        std::cout << "Button 处理鼠标点击\n";
        Widget::onEvent(e);  // 可选：调用基类默认处理
    }
};

// 使用
int main() {
    Button btn;
    btn.onEvent(MouseEvent{});   // Button::onEvent(MouseEvent)
    btn.onEvent(KeyEvent{});     // Widget::onEvent(KeyEvent) - 仍然可用！
    btn.onEvent(ResizeEvent{});  // Widget::onEvent(ResizeEvent) - 仍然可用！
}

场景2：自定义容器的接口暴露

#include <vector>
#include <algorithm>

// 自定义一个有序数组，继承自 std::vector（仅为示例，实际不推荐 public 继承 STL 容器）
template<typename T>
class SortedVector : private std::vector<T> {
public:
    // 使用转交函数暴露需要的接口
    using typename std::vector<T>::size_type;
    using typename std::vector<T>::iterator;
    using typename std::vector<T>::const_iterator;
    
    // 转交函数：暴露 size()
    size_type size() const {
        return std::vector<T>::size();
    }
    
    // 转交函数：暴露迭代器
    iterator begin() { return std::vector<T>::begin(); }
    iterator end() { return std::vector<T>::end(); }
    const_iterator begin() const { return std::vector<T>::begin(); }
    const_iterator end() const { return std::vector<T>::end(); }
    
    // 自定义：插入时保持有序
    void insert(const T& value) {
        auto it = std::lower_bound(std::vector<T>::begin(), 
                                    std::vector<T>::end(), value);
        std::vector<T>::insert(it, value);
    }
    
    // 注意：我们不暴露 push_back，因为它会破坏有序性！
    // 也不暴露 operator[]，因为直接修改元素也会破坏有序性
    
    // 但暴露 at() 用于只读访问
    const T& at(size_type index) const {
        return std::vector<T>::at(index);
    }
};

场景3：游戏开发中的技能系统

class Skill {
public:
    virtual ~Skill() = default;
    
    // 多种使用方式
    virtual void cast() {
        std::cout << "释放技能\n";
    }
    
    virtual void cast(Entity& target) {
        std::cout << "对目标释放技能\n";
    }
    
    virtual void cast(const Vec3& position) {
        std::cout << "对位置释放技能\n";
    }
    
    virtual void cast(Entity& target, const Vec3& position) {
        std::cout << "对目标在指定位置释放技能\n";
    }
};

class Fireball : public Skill {
public:
    using Skill::cast;  // 引入所有 cast 重载
    
    void cast() override {
        std::cout << "释放火球术！\n";
        createFireEffect();
    }
    
    void cast(Entity& target) override {
        std::cout << "向 " << target.getName() << " 发射火球！\n";
        applyDamage(target, 50);
        createFireEffect();
    }
    
    // cast(Vec3) 和 cast(Entity&, Vec3) 继承自 Skill，仍然可用

private:
    void createFireEffect() {
        std::cout << "创建火焰特效\n";
    }
    
    void applyDamage(Entity& target, int damage) {
        target.takeDamage(damage);
    }
};

六、重载、重写、隐藏的区别

这是 C++ 继承中最容易混淆的三个概念，我们来彻底理清：

class Base {
public:
    void func(int) {}           // 1. 基类版本
    virtual void vfunc(int) {}  // 2. 虚函数
};

class Derived : public Base {
public:
    void func(int) {}           // 3. 隐藏（hide）基类的 func(int)
    void func(double) {}        // 4. 重载（overload）Derived::func(int)
                                  //    同时也隐藏了 Base::func(int)
    void vfunc(int) override {} // 5. 重写（override）Base::vfunc(int)
};
概念英文发生条件作用域是否要求 virtual
重载Overload同名函数，参数不同同一作用域否
重写Override函数签名完全相同基类与派生类是（基类必须有 virtual）
隐藏Hide同名即可（参数可不同）基类与派生类否
// 详细对比示例
class Base {
public:
    void func(int) { std::cout << "Base::func(int)\n"; }
    virtual void vfunc(int) { std::cout << "Base::vfunc(int)\n"; }
};

class Derived : public Base {
public:
    void func(int) { std::cout << "Derived::func(int)\n"; }        // 隐藏
    void func(double) { std::cout << "Derived::func(double)\n"; }  // 重载 + 隐藏
    void vfunc(int) override { std::cout << "Derived::vfunc(int)\n"; } // 重写
};

int main() {
    Derived d;
    Base& b = d;
    
    d.func(10);      // Derived::func(int) - 静态绑定
    d.func(3.14);    // Derived::func(double) - 重载解析
    
    b.func(10);      // Base::func(int) - 不是虚函数，静态绑定
    b.vfunc(10);     // Derived::vfunc(int) - 虚函数，动态绑定
    
    // d.func(10) 调用的是 Derived::func(int)，Base::func(int) 被隐藏了
    // 如果想调用基类版本：
    d.Base::func(10);  // 显式调用基类版本
}

七、private 继承中的特殊考量

在 private 继承中，基类的 public 成员在派生类中变成 private。如果你希望暴露某些接口，转交函数特别有用：

class Timer {
public:
    void start() { /* ... */ }
    void stop() { /* ... */ }
    double elapsed() const { /* ... */ }
};

class Animation : private Timer {
public:
    // 使用转交函数选择性暴露 Timer 的接口
    void start() { Timer::start(); }
    double elapsed() const { return Timer::elapsed(); }
    // 注意：不暴露 stop()，Animation 自己控制停止时机
    
    void update() {
        if (elapsed() > duration_) {
            // 动画结束
            Timer::stop();
        }
    }

private:
    double duration_;
};

八、总结

要点说明
名字遮掩规则派生类中的名字会遮掩基类中所有同名名字，与参数列表无关
原因C++ 的名字查找在找到第一个匹配后就停止
影响基类的重载函数版本可能被意外隐藏
using 声明将基类中某个名字的所有重载引入派生类作用域
转交函数精确控制暴露哪些基类接口，可添加额外逻辑

请记住：

  • derived classes 内的名称会遮掩 base classes 内的名称。在 public 继承下从来没有人希望如此。
  • 为了让被遮掩的名称再见天日，可使用 using 声明式或转交函数（forwarding functions）。
  • using 声明适用于需要暴露基类所有重载版本的场景。
  • 转交函数适用于需要选择性暴露或添加额外处理的场景。

名字遮掩是 C++ 中一个隐蔽但重要的陷阱。在 public 继承中，我们期望派生类扩展基类的行为，而不是限制它。养成使用 using 声明的习惯，可以让你的继承体系更加健壮和透明。

参考：《Effective C++》第三版，Scott Meyers 著

相关条款：条款32（确定 public 继承塑模出 is-a 关系）、条款34（区分接口继承和实现继承）、条款39（明智而审慎地使用 private 继承）

标签
#c++ #开发语言 #服务器 #linux #嵌入式开发
Effective C++条款33：避免遮掩继承而来的名称（Avoid hiding inherited names）
CltCj的博客
12-20 667
Effective C++条款33：避免遮掩继承而来的名称（Avoid hiding inherited names）
Effective C++条款33 避免遮掩继承而来的名字
zion--6135的博客
01-16 166
名称遮掩 int x = 20; void someFunc() { double x = 10.0; std::cout << x; ] 如上操作，函数打印结果是10.0还是20呢？是10.0。因为代码访问顺序是这样的，当需要变量x，现在someFun()函数里找，找不到x，再全局找x。本例：double x遮掩了int x 继承中的名称遮掩 Derived类的调用作用域顺序 class Base { public: virtual v
effective c++ 条款33：避免遮掩继承而来的名字
DXT的博客
02-26 191
  #include&lt;iostream&gt; using namespace std; class Base { public: virtual void f1() = 0; virtual void f1(int) { cout &lt;&lt; "base f1(int)" &lt;&lt; endl; }; virtual void f2() { cout &lt;&...
Effective C++条款33：继承与面向对象之（避免遮掩继承而来的名字）
董哥的黑板报
03-10 828
待续
Effective C++条款33：继承与面向对象——避免遮掩继承而来的名字
www_dong的博客
02-09 163
一、变量隐藏使用规则 当全局和局部存在相同的变量时，在局部作用域中，全局作用域的变量名会被隐藏，优先使用局部的变量 例如： int x; //全局变量 void someFunc() { double x; //局部变量 std::cin >> x; //局部变量赋值 ] 二、继承中的隐藏与重写(覆盖) 当基类中定义的变量/成员函数，派生类也定义同名的时，基类的变量/成员函数就会在派生类中被隐藏 演示案例 class Base { privat
Effective C++ 之条款33避免遮掩继承而来的名称
godqiao的博客
04-16 309
名称的遮掩可以分为变量的遮掩和函数的遮掩两类，本质上都是通过名字的查找方式导致的，当编译器查找一个名字的时候，他一旦找到一个相符的名字，他就不会再找下去了，所以核心是看它从哪个作用域先找，因为查找是分作用域的。 //例1：普通变量遮掩 int i = 3; //global 变量 int main() { int i = 4; //local变量 cout &lt...
读书笔记《Effective C++》条款33：避免遮掩继承而来的名称
Do-Program的专栏
05-24 347
我们知道在诸如这般的代码中： int x;//global变量 void someFunc() { double x;//local变量 std::cin >> x;//读一个新值赋予local变量x }这个读取数据的语句指涉的是local变量x，而不是global变量x，因为内层作用域的名称会遮掩外围作用域的名称。 当编译器处于someFunc的作用域内并遭遇
避免遮掩继承而来的名称（Effective C++_33）
午后斜阳
09-14 528
一、名字覆盖规则名称的遮掩可以分成变量的遮掩与函数的遮掩两类；查找规则：一般先查找局部作用域，然后再查找外围作用域；对于含有继承关系的类，先查找局部作用域，再查找派生类覆盖的作用域，然后再查找基类覆盖的作用域，如果都没有找到，最后查找全局作用域；二、基类成员函数被覆盖 （1）看一段代码：#include <iostream> using namespace std;class Base { pri
Effective_C++_条款三十三：避免遮掩继承而来的名称
Likes的博客
06-11 201
名称的遮掩可以分成变量的遮掩与函数的遮掩两类，本质都是名字的查找方式导致的，当编译器要去查找一个名字时，它一旦找到一个相符的名字，就不会再往下去找了，因此遮掩本质上是优先查找哪个名字的问题。 而查找是分作用域的，虽然本条款的命名是打着“继承”的旗子来说的，但我觉得其实与继承并不是很有关系，关键是作用域。 举例子说明这个问题会比较好理解。 //例1：普通变量遮掩 int i = 3; in...
Effective C++ 条款33 避免遮掩继承而来的名称
ddzai7557的博客
09-09 101
1. C++基类和派生类的作用域为嵌套关系,同时存在作用域屏蔽规则,例如: class Base{ public: void f(); ... private: int a; ... } class Derived:public Base{ ... } View Code 那么Derived和Base之间的作用...
《Effective C++》条款33、避免遮掩而来的名字
qq_44664843的博客
03-30 181
对于继承关系中得函数得同名作用域问题，现在已经清楚编译器是如何去对作用域进行查找的了，但是我们依然需要了解在继承和虚函数的关系中，我们的同名e问题是怎样的。 参考下面一段代码： 上面的继承关系中，派生类和基类中的函数出现了同名的问题，这时，派生类中的同名函数将会遮掩掉所有基类中的同名函数。如下的用法将会更加清晰： 即使派生类中的函数和基类中的有所不同，但是在派生类对象中，也无法调用基类中的同名函数。 使用using避免同名函数遮掩问题 我们可以使用using声名将派生类中的同名函数引入到派生类中，这样便
Effective C++ 条款32、33
coolwriter的博客
03-28 427
条款三十二：确定你的public继承继承塑模出is-a关系 这一条款是说的是公有继承的逻辑，如果使用继承，而且继承是公有继承的话，一定要确保子类是一种父类（is-a关系）。这种逻辑可能与生活中的常理不相符，比如企鹅是生蛋的，所有企鹅是鸟类的一种，直观来看，我们可以用公有继承描述： class Bird { public: virtual void fly(){cout &lt;&l...
effective c++ 笔记 条款32-40
Mhypnos的博客
03-06 1236
effective c++读书笔记
【C++】万字详解Effective C++
Friday
10-28 4104
本文为前段时间读《Effective C++》（侯捷译）时做的个人笔记。
【Effective C++ 条款29-33 笔记】【为异常安全而努力】【透彻了解inline】【确定public继承塑造出is-a关系】【避免遮掩继承来的名称】
日月既往，不可复追
11-21 758
条款29：为异常安全而努力 当异常被抛出时，具有异常安全的函数会： 不泄露资源 不丢失数据 copy and swap(CAS)： 为打算修改的对象创建一份副本，在副本上进行一系列修改。在修改副本的过程中抛出任何异常，原对象不受影响。当所有的改变都成功后，将修改之后的副本和原对象在一个不抛出异常的操作中置换 条款30：透彻了解inline inline函数能够避免函数调用的开销，还能够让编译器对inline函数进行优化 这是因为inline函数的机制是：在编译期以函数本体替换对inline函数的每一个调
带你读懂Effective C++(六): 继承与面向对象设计
likuoelie的博客
02-12 984
《Effective C++》第六章深入探讨了继承与面向对象设计的核心原则。重点包括：public继承必须严格遵循"is-a"关系（Item 32）；避免名称遮掩（Item 33）；区分接口继承与实现继承（Item 34）；考虑虚函数的替代方案如策略模式（Item 35）；绝不重定义non-virtual函数（Item 36）和默认参数值（Item 37）。此外，强调复合优于继承（Item 38），审慎使用private继承（Item 39）和多重继承（Item 40）。本章提供了一套完
Effective_C++_条款四十：明智而审慎地使用多重继承
Likes的博客
06-12 210
多重继承是一种比较复杂的继承关系，它意味着如果用户想要使用这个类，那么就要对它的父类也了如指掌，所以在项目中会带来可读性的问题，一般我们都会尽量选择用单继承去替代它。 使用多重继承过程容易碰到的问题就是名字冲突，像下面这样： class Base1 { public: void fun(){} }; class Base2 { private: void fun(){} }...
C++ STL之set/multiset详解：从使用到底层，再到面试八股
最新发布
Rick_Theseusr的博客
06-30 303
本文详细介绍了C++ STL中的set和multiset容器的使用方法和底层原理。主要内容包括：容器的初始化、插入操作（insert返回值特性）、删除操作（erase的不同用法）、查找方法（find/count/contains）、边界查询（lower_bound/upper_bound/equal_range）以及遍历方式。特别强调了set自动去重和排序的特性，multiset允许重复元素的区别，以及二者在不同操作上的表现差异。文章还提供了常用函数的时间复杂度参考，适合面试准备和日常开发查阅。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

凡人叶枫

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值