C++继承和派生

最新推荐文章于 2024-09-14 16:21:49 发布
最新推荐文章于 2024-09-14 16:21:49 发布
阅读量787 收藏 11
点赞数 31
分类专栏： 程序设计基础cpp 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Darling912/article/details/141102810
版权

4.7 继承和派生

4.7.1 继承概述

4.7.1.1 为什么需要继承

网页类

class IndexPage{

public:

//网页头部

void Header(){

cout << "网页头部!" << endl;

}

//网页左侧菜单

void LeftNavigation(){

cout << "左侧导航菜单!" << endl;

}

//网页主体部分

void MainBody(){

cout << "首页网页主题内容!" << endl;

}

//网页底部

void Footer(){

cout << "网页底部!" << endl;

}

private:

string mTitle; //网页标题

};

#if 0

//如果不使用继承，那么定义新闻页类，需要重新写一遍已经有的代码

class NewsPage{

public:

//网页头部

void Header(){

cout << "网页头部!" << endl;

}

//网页左侧菜单

void LeftNavigation(){

cout << "左侧导航菜单!" << endl;

}

//网页主体部分

void MainBody(){

cout << "新闻网页主体内容!" << endl;

}

//网页底部

void Footer(){

cout << "网页底部!" << endl;

}

private:

string mTitle; //网页标题

};

void test(){

NewsPage* newspage = new NewsPage;

newspage->Header();

newspage->MainBody();

newspage->LeftNavigation();

newspage->Footer();

}

#else

//使用继承，可以复用已有的代码，新闻业除了主体部分不一样，其他都是一样的

class NewsPage : public IndexPage{

public:

//网页主体部分

void MainBody(){

cout << "新闻网页主主体内容!" << endl;

}

};

void test(){

NewsPage* newspage = new NewsPage;

newspage->Header();

newspage->MainBody();

newspage->LeftNavigation();

newspage->Footer();

}

#endif

int main(){

test();

return EXIT_SUCCESS;

}

4.7.1.2 继承基本概念

c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。

一个B类继承于A类，或称从类A派生类B。这样的话，类A成为基类（父类）， 类B成为派生类（子类）。

派生类中的成员，包含两大部分：

  1. 一类是从基类继承过来的，一类是自己增加的成员。
  2. 从基类继承过过来的表现其共性，而新增的成员体现了其个性。
4.7.1.3 派生类定义

派生类定义格式：

   Class 派生类名 :  继承方式 基类名{

         //派生类新增的数据成员和成员函数

   }

三种继承方式：

    1. public ：    公有继承
    2. private ：   私有继承
    3. protected ： 保护继承

从继承源上分：

  1. 单继承：指每个派生类只直接继承了一个基类的特征
  2. 多继承：指多个基类派生出一个派生类的继承关系,多继承的派生类直接继承了不止一个基类的特征

4.7.2 派生类访问控制

派生类继承基类，派生类拥有基类中全部成员变量和成员方法（除了构造和析构之外的成员方法），但是在派生类中，继承的成员并不一定能直接访问，不同的继承方式会导致不同的访问权限。

派生类的访问权限规则如

//基类

class A{

public:

int mA;

protected:

int mB;

private:

int mC;

};

//1. 公有(public)继承

class B : public A{

public:

void PrintB(){

cout << mA << endl; //可访问基类public属性

cout << mB << endl; //可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

class SubB : public B{

void PrintSubB(){

cout << mA << endl; //可访问基类public属性

cout << mB << endl; //可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

void test01(){

B b;

cout << b.mA << endl; //可访问基类public属性

//cout << b.mB << endl; //不可访问基类protected属性

//cout << b.mC << endl; //不可访问基类private属性

}

//2. 私有(private)继承

class C : private A{

public:

void PrintC(){

cout << mA << endl; //可访问基类public属性

cout << mB << endl; //可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

class SubC : public C{

void PrintSubC(){

//cout << mA << endl; //不可访问基类public属性

//cout << mB << endl; //不可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

void test02(){

C c;

//cout << c.mA << endl; //不可访问基类public属性

//cout << c.mB << endl; //不可访问基类protected属性

//cout << c.mC << endl; //不可访问基类private属性

}

//3. 保护(protected)继承

class D : protected A{

public:

void PrintD(){

cout << mA << endl; //可访问基类public属性

cout << mB << endl; //可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

class SubD : public D{

void PrintD(){

cout << mA << endl; //可访问基类public属性

cout << mB << endl; //可访问基类protected属性

//cout << mC << endl; //不可访问基类private属性

}

};

void test03(){

D d;

//cout << d.mA << endl; //不可访问基类public属性

//cout << d.mB << endl; //不可访问基类protected属性

//cout << d.mC << endl; //不可访问基类private属性

}

4.7.3 继承中的构造和析构

4.7.3.1 继承中的对象模型

在C++编译器的内部可以理解为结构体，子类是由父类成员叠加子类新成员而成：

class Aclass{

public:

int mA;

int mB;

};

class Bclass : public Aclass{

public:

int mC;

};

class Cclass : public Bclass{

public:

int mD;

};

void test(){

cout << "A size:" << sizeof(Aclass) << endl;

cout << "B size:" << sizeof(Bclass) << endl;

cout << "C size:" << sizeof(Cclass) << endl;

}

查看类继承的内部模型：

找到VS2013开发人员命令提示程序(一般在：C:\Program Files (x86)\Microsoft Visual Studio 12.0\Common7\Tools\Shortcuts)，打开，然后复制你工程路径，命令：cd 路径，进入你工程文件夹中(如果工程不在C盘在E盘的话，要再E:下)，然后命令：cl /d1 reportSingleClassLayout类名 文件名全称

如：cl /d1 reportSingleClassLayoutSon test.cpp

4.7.3.2 对象构造和析构的调用原则
  1. 继承中的构造和析构
  • 子类对象在创建时会首先调用父类的构造函数
  • 父类构造函数执行完毕后，才会调用子类的构造函数
  • 当父类构造函数有参数时，需要在子类初始化列表(参数列表)中显示调用父类构造函数
  • 析构函数调用顺序和构造函数相反

class A{

public:

A(){

cout << "A类构造函数!" << endl;

}

~A(){

cout << "A类析构函数!" << endl;

}

};

class B : public A{

public:

B(){

cout << "B类构造函数!" << endl;

}

~B(){

cout << "B类析构函数!" << endl;

}

};

class C : public B{

public:

C(){

cout << "C类构造函数!" << endl;

}

~C(){

cout << "C类析构函数!" << endl;

}

};

void test(){

C c;

}

  1. 继承与组合混搭的构造和析构

class D{

public:

D(){

cout << "D类构造函数!" << endl;

}

~D(){

cout << "D类析构函数!" << endl;

}

};

class A{

public:

A(){

cout << "A类构造函数!" << endl;

}

~A(){

cout << "A类析构函数!" << endl;

}

};

class B : public A{

public:

B(){

cout << "B类构造函数!" << endl;

}

~B(){

cout << "B类析构函数!" << endl;

}

};

class C : public B{

public:

C(){

cout << "C类构造函数!" << endl;

}

~C(){

cout << "C类析构函数!" << endl;

}

public:

D c;

};

void test(){

C c;

}

4.7.3 继承中同名成员的处理方法

  1. 当子类成员和父类成员同名时，子类依然从父类继承同名成员
  2. 如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域，就近原则)
  3. 在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符)

  

class Base{

public:

Base():mParam(0){}

void Print(){ cout << mParam << endl; }

public:

int mParam;

};

class Derived : public Base{

public:

Derived():mParam(10){}

void Print(){

//在派生类中使用和基类的同名成员,显示使用类名限定符

cout << Base::mParam << endl;

cout << mParam << endl;

}

//返回基类重名成员

int& getBaseParam(){ return  Base::mParam; }

public:

int mParam;

};

int main(){

Derived derived;

//派生类和基类成员属性重名，子类访问成员默认是子类成员

cout << derived.mParam << endl; //10

derived.Print();

//类外如何获得基类重名成员属性

derived.getBaseParam() = 100;

cout << "Base:mParam:" << derived.getBaseParam() << endl;

return EXIT_SUCCESS;

}

注意: 如果重新定义了基类中的重载函数，将会发生什么？

class Base{

public:

//重载函数

void func1(){

cout << "Base::void func1()" << endl;

};

void func1(int param){

cout << "Base::void func1(int param)" << endl;

}

//非重载函数

void myfunc(){

cout << "Base::void myfunc()" << endl;

}

};

class Derived1 : public Base{};

class Derived2 : public Base{

public:

void myfunc(){

//基类myfunc被隐藏，可通过类作用域运算符指定调用基类myfunc函数

//Base::myfunc();

cout << "Derived2::void myfunc()" << endl;

}

};

class Derived3 : public Base{

public:

//改变成员函数的参数列表

void func1(int param1, int param2){

//Base::func1(10);  //类的内部可通过类作用域运算符访问基类重载版本的函数

cout << "Derived3::void func1(int param1,int param2)" << endl;

};

};

class Derived4 : public Base{

public:

//改变成员函数的返回值

int func1(int param){

Base::func1(10);

cout << "Derived4::int func1(int param)" << endl;

return 0;

}

};

//和基类非重载函数重名

void test01(){

Derived1 derived1;

derived1.myfunc();

//和基类函数重名

Derived2 derived2;

derived2.myfunc();

}

//和基类重载函数重名

void test02(){

Derived3 derived3;

//derived3.func1();  //基类重载版本的函数fun1被全部隐藏，子类外部不可访问

//derived3.func1(10);

derived3.func1(10,20);

Derived4 derived4;

//derived4.func1(); //基类重载版本的函数fun1被全部隐藏，子类外部不可访问

derived4.func1(10);

}

//结论：任何时候重新定义基类中的任何一个函数，子类中这种函数的任何版本都会被隐藏(非覆盖，可通过类作用域运算符调用)

任何时候重新定义基类中的一个重载函数，在新类中所有的其他版本将被自动隐藏.

4.7.4 非自动继承的函数

不是所有的函数都能自动从基类继承到派生类中。构造函数和析构函数用来处理对象的创建和析构操作，构造和析构函数只知道对它们的特定层次的对象做什么，也就是说构造函数和析构函数不能被继承，必须为每一个特定的派生类分别创建。

另外operator=也不能被继承，因为它完成类似构造函数的行为。也就是说尽管我们知道如何由=右边的对象如何初始化=左边的对象的所有成员，但是这个并不意味着对其派生类依然有效。

在继承的过程中，如果没有创建这些函数，编译器会自动生成它们。

4.7.5 继承中的静态成员特性

静态成员函数和非静态成员函数的共同点:

  1. 他们都可以被继承到派生类中。
  2. 如果重新定义一个静态成员函数，所有在基类中的其他重载函数会被隐藏。
  3. 如果我们改变基类中一个函数的特征，所有使用该函数名的基类版本都会被隐藏。

静态成员函数不能是虚函数（virtual function）.

class Base{

public:

static int getNum(){ return sNum; }

static int getNum(int param){

return sNum + param;

}

public:

static int sNum;

};

int Base::sNum = 10;

class Derived : public Base{

public:

static int sNum; //基类静态成员属性将被隐藏

#if 0

//重定义一个函数，基类中重载的函数被隐藏

static int getNum(int param1, int param2){

return sNum + param1 + param2;

}

#else

//改变基类函数的某个特征，返回值或者参数个数，将会隐藏基类重载的函数

static void getNum(int param1, int param2){

cout <<  sNum + param1 + param2 << endl;

}

#endif

};

int Derived::sNum = 20;

4.7.6 多继承

4.7.6.1 多继承概念

我们可以从一个类继承，我们也可以能同时从多个类继承，这就是多继承。但是由于多继承是非常受争议的，从多个类继承可能会导致函数、变量等同名导致较多的歧义。

class Base1{

public:

void func1(){ cout << "Base1::func1" << endl; }

};

class Base2{

public:

void func1(){ cout << "Base2::func1" << endl; }

void func2(){ cout << "Base2::func2" << endl; }

};

//派生类继承Base1、Base2

class Derived : public Base1, public Base2{};

int main(){

Derived derived;

//func1是从Base1继承来的还是从Base2继承来的？

//derived.func1();

derived.func2();

//解决歧义:显示指定调用那个基类的func1

derived.Base1::func1(); 

derived.Base2::func1();

return EXIT_SUCCESS;

}

多继承会带来一些二义性的问题， 如果两个基类中有同名的函数或者变量，那么通过派生类对象去访问这个函数或变量时就不能明确到底调用从基类1继承的版本还是从基类2继承的版本？

解决方法就是显示指定调用那个基类的版本。

4.7.6.2 菱形继承和虚继承

两个派生类继承同一个基类而又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石型继承。

这种继承所带来的问题：

  1. 羊继承了动物的数据和函数，鸵同样继承了动物的数据和函数，当草泥马调用函数或者数据时，就会产生二义性。
  2. 草泥马继承自动物的函数和数据继承了两份，其实我们应该清楚，这份数据我们只需要一份就可以。

class BigBase{

public:

BigBase(){ mParam = 0; }

void func(){ cout << "BigBase::func" << endl; }

public:

int mParam;

};

class Base1 : public BigBase{};

class Base2 : public BigBase{};

class Derived : public Base1, public Base2{};

int main(){

Derived derived;

//1. 对“func”的访问不明确

//derived.func();

//cout << derived.mParam << endl;

cout << "derived.Base1::mParam:" << derived.Base1::mParam << endl;

cout << "derived.Base2::mParam:" << derived.Base2::mParam << endl;

//2. 重复继承

cout << "Derived size:" << sizeof(Derived) << endl; //8

return EXIT_SUCCESS;

}

上述问题如何解决？对于调用二义性，那么可通过指定调用那个基类的方式来解决，那么重复继承怎么解决？

对于这种菱形继承所带来的两个问题，c++为我们提供了一种方式，采用虚基类。那么我们采用虚基类方式将代码修改如下：

class BigBase{

public:

BigBase(){ mParam = 0; }

void func(){ cout << "BigBase::func" << endl; }

public:

int mParam;

};

class Base1 : virtual public BigBase{};

class Base2 : virtual public BigBase{};

class Derived : public Base1, public Base2{};

int main(){

Derived derived;

//二义性问题解决

derived.func();

cout << derived.mParam << endl;

//输出结果:12

cout << "Derived size:" << sizeof(Derived) << endl;

return EXIT_SUCCESS;

}

以上程序Base1 ，Base2采用虚继承方式继承BigBase,那么BigBase被称为虚基类。

通过虚继承解决了菱形继承所带来的二义性问题。

但是虚基类是如何解决二义性的呢？并且derived大小为12字节，这是怎么回事？

4.7.6.3 虚继承实现原理

class BigBase{

public:

BigBase(){ mParam = 0; }

void func(){ cout << "BigBase::func" << endl; }

public: int mParam;

};

#if 0 //虚继承

class Base1 : virtual public BigBase{};

class Base2 : virtual public BigBase{};

#else //普通继承

class Base1 :  public BigBase{};

class Base2 :  public BigBase{};

#endif

class Derived : public Base1, public Base2{};

普通继承

虚继承

BigBase：

Base1：

Base2：

Derived：

通过对象布局图，我们发现普通继承和虚继承的对象内存图是不一样的。我们也可以猜测到编译器肯定对我们编写的程序做了一些手脚。

  • BigBase 菱形最顶层的类，内存布局图没有发生改变。
  • Base1和Base2通过虚继承的方式派生自BigBase,这两个对象的布局图中可以看出编译器为我们的对象中增加了一个vbptr (virtual base pointer),vbptr指向了一张表，这张表保存了当前的虚指针相对于虚基类的首地址的偏移量。
  • Derived派生于Base1和Base2,继承了两个基类的vbptr指针，并调整了vbptr与虚基类的首地址的偏移量。

由此可知编译器帮我们做了一些幕后工作，使得这种菱形问题在继承时候能只继承一份数据，并且也解决了二义性的问题。现在模型就变成了Base1和 Base2 、Derived三个类对象共享了一份BigBase数据。

当使用虚继承时，虚基类是被共享的，也就是在继承体系中无论被继承多少次，对象内存模型中均只会出现一个虚基类的子对象（这和多继承是完全不同的）。即使共享虚基类，但是必须要有一个类来完成基类的初始化（因为所有的对象都必须被初始化，哪怕是默认的），同时还不能够重复进行初始化，那到底谁应该负责完成初始化呢？C++标准中选择在每一次继承子类中都必须书写初始化语句（因为每一次继承子类可能都会用来定义对象），但是虚基类的初始化是由最后的子类完成，其他的初始化语句都不会调用。

class BigBase{

public:

BigBase(int x){mParam = x;}

void func(){cout << "BigBase::func" << endl;}

public:

int mParam;

};

class Base1 : virtual public BigBase{

public:

Base1() :BigBase(10){} //不调用BigBase构造

};

class Base2 : virtual public BigBase{

public:

Base2() :BigBase(10){} //不调用BigBase构造

};

class Derived : public Base1, public Base2{

public:

Derived() :BigBase(10){} //调用BigBase构造

};

//每一次继承子类中都必须书写初始化语句

int main(){

Derived derived;

return EXIT_SUCCESS;

}

注意：

    虚继承只能解决具备公共祖先的多继承所带来的二义性问题，不能解决没有公共祖先的多继承的.

工程开发中真正意义上的多继承是几乎不被使用，因为多重继承带来的代码复杂性远多于其带来的便利，多重继承对代码维护性上的影响是灾难性的，在设计方法上，任何多继承都可以用单继承代替。

   Jerry Schwarz,输入输出流(iostream)的作者，曾在个别场合表示如何他重新设计iostream的话，很可能从iostream中去除多重继承。

Geeks.
关注
专栏目录
C++基础六
OldApple_MrZ的博客
08-26 195
C++基础学习六继承和派生继承基本概念派生类定义三种继承方式：从继承源上分：派生类访问控制继承中的构造和析构继承中的对象模型对象构造和析构的调用原则继承中同名成员的处理方法非自动继承的函数继承中的静态成员特性多继承多继承概念菱形继承和虚继承虚继承实现原理 virtual查看内存布局(对象模型)Developer Command Prompt(开发人员命令提示)cl /d1 reportSingl...
C++ 继承和派生
小白杨的博客
08-01 144
1 继承概念 1)继承是类之间定义的一种重要关系; 2)基本语法：class Child : public Parent1，public Parent2; 3)Parent称基类（父类），child称派生类（子类） 4) 继承方式:public,private,protected. 5)重要说明: a)子类拥有父类的所有成员变量和成员函数; b)子类可以拥有父类没有的方法和属性; ...
c++ 类的继承
tranquilllll的博客
03-24 8663
一、类的基本概念 c++最重要的特征是代码重用，通过继承机制可以利用已有的数据类型来定义新的数据类型，新的类不仅拥有旧类的成员，还拥有新定义的成员。 一个 B 类继承于A类，或称从类 A 派生类 B。这样的话，类 A 成为基类（父类）， 类B成为派生 类（子类）。 派生类中的成员，包含两大部分： 一类是从基类继承过来的，一类是自己增加的成员。 从基类继承过过来的表现其共性，而新增的成员体现了其个性。 继承的优点：减少代码的冗余 提高代码的重用性 二、继承的格式 派生类定义格式： Class 派生类
45 C++ - 继承中同名成员的处理方法
阿甘兄
10-09 401
1.当子类成员和父类成员同名时，子类依然从父类继承同名成员 2.如果子类有成员和父类同名，子类访问其成员默认访问子类的成员(本作用域，就近原则) 3.在子类通过作用域::进行同名成员区分(在派生类中使用基类的同名成员，显示使用类名限定符) class Base{ public: Base():mParam(0){} void Print(){ cout << mParam <...
base（）
牛wan
03-05 1959
using System; namespace RectangleApplication { class Rectangle { // 成员变量 protected double length; protected double width; public Rectangle(double l, double w) { ...
C++继承和派生的基本概念
wo_ai_luo_的博客
11-10 1019
需要继承机制的例子继承和派生的概念继承：在定义一个新的类B时，如果该类与某个已有的类A相似(指的是B拥有A的全部特点)，那么就可以把A作为一个，而把B作为基类的一个。派生类是通过对基类进行修改和扩充得到的。在派生类中，可以扩充新的成员变量和成员函数。派生类一经定义后，可以独立使用，不依赖于基类。派生类拥有基类的全部成员函数和成员变量，不论是private、protected、public。在派生类的各个成员函数中，不能访问基类中的private成员。接下来我们来讲几个例子!
代码讲解C++继承和派生
12-31
继承是是指一个对象直接使用另一对象的属性和方法。 继承的作用： 1.描述客观事物的层次结构 2.分类的方法进行分析和描述 3.复杂的系统层次化，提高代码的重用性 4.增强语言功能，提高软件开发效益 继承分为单...
【C++初阶】：C++入门，引用概念及其性质
书山有路勤为径，学海无涯苦作舟。
09-10 1158
是的，你没看错，引用不仅可以做函数的参数，还可以做函数的返回值，我们之前写的具有返回值的函数返回的并不是直接将函数中的变量，而是返回的变量的一份临时拷贝，而拷贝是需要付出一定代价的，这样会降低我们代码的效率，但是如果我们用引用返回的话就可以避免拷贝的代价，在对程序性能要求高且允许使用引用的情况下，尽量使用引用返回。除了上述情况，引用的类型不同也会导致编译不同过，这是因为在发生类型转化的过程中，会产生临时变量，而临时变量具有常性，和常量一样，需要用。一个变量被引用后，可以继续被引用，也可以引用变量的引用。
【C++ 面试 - 新特性】每日 3 题（九）
Newin2020的博客
09-10 650
✍个人博客：Pandaconda-CSDN博客📣专栏地址：http://t.csdnimg.cn/fYaBd📚专栏简介：在这个专栏中，我将会分享 C++ 面试中常见的面试题给大家~
Linux和C语言（Day10）
weixin_65095004的博客
09-10 1156
实现特定功能的代码块定义函数： 存储类型 数据类型 函数名(参数列表){ 实现特定功能的代码块 }
Linux 下 C/C++ 程序编译的过程
Teminator_的博客
09-08 9551
本文将介绍如何将 C/C++ 语言编写的程序转换成为处理器能够执行的二进制代码的过程，包括四个步骤：预处理（）编译（）汇编（）链接（在此之前，首先来看一下 GCC 工具链。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 861
set、map仿STL模拟实现
C和指针：预处理(#include/define/if...)
暮色年华的博客
09-10 724
预处理器把所有name替换成 stuff。在程序中扩展#define定义符号和宏时，需要涉及几个步骤：1.在调用宏时，首先对参数进行检查，看看是否包含了任何由#define 定义的符号。如果是，它们首先被替换。2.替换文本随后被插入到程序中原来文本的位置。对于宏，参数名被它们的值所替代。3.最后，再次对结果文本进行扫描，看看它是否包含了任何由#define 定义的符号。如果是，就重复上述处理过程。这样，宏参数和#define 定义可以包含其他#define定义的符号。但是，宏不可以出现递归。
【C++ && Qt day11】
wzj46的博客
09-11 249
2、头文件窗口文件。
集群聊天服务器项目【C++】（二）Json的简单使用
最新发布
xaiobai123的博客
09-14 402
Json是一种轻量级的数据交换格式（也叫数据序列化方式）。Json采用完全独立于编程语言的文本格式来存储和表示数据。简洁和清晰的层次结构使得 Json 成为理想的数据交换语言。易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。在网络传输中，一般有3中常见的序列化格式：XML，Json、ProtoBufProtoBuf：数据压缩编码传输，占用带宽小，复杂Json：相比与ProtoBuf更简单，但性能差一点XML：性能差本项目使用Json完成网络数据的序列化与反序列化。
CCF201903_1
m0_67663419的博客
09-14 115
【代码】CCF201903_1。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值