C++学习之路 day7

最新推荐文章于 2024-04-22 18:35:39 发布
最新推荐文章于 2024-04-22 18:35:39 发布
阅读量299 收藏
点赞数 1
分类专栏： 【C++学习】 文章标签： C++基础知识学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zay_myxq/article/details/77619442
版权

Day7知识点：

1.类的继承，是新的类从已有类那里得到已有的特性；类的派生，从已有类产生新类的过程。原有的类称为基类或父类，产生的新类称为派生类或子类。

C++通过继承，来实现代码的重用性。


继承的实验代码：


#include <iostream>

using namespace std;

#if 0
Inherit&Derive
学生 姓名，年龄，性别，学号，吃饭，学习
老师 姓名，年龄，性别，工号，吃饭，教学

        姓名，年龄，性别，吃饭           父类  基类
                                     继承  派生
学生：学号，学习      老师：工号，教学     子类  派生类；
#endif


class Human                 //父类    共性
{
public:
    void eat(string food)
    {
        cout<<"I am eating"<<food<<endl;
    }
};

class Student:public Human      //子类 是在父类的基础上增加新的功能，体现的是共性
{
public:
    void study(string course)
    {
        cout<<"I am a student , I am learning"<<course<<endl;
    }
};

class Teacher:public Human
{
public:
    void tech(string course)
    {
        cout<<"I am a teacher , I am teaching"<<course<<endl;
    }
};
int main()
{
    Student s;
    s.study("c++");
    s.eat("黄焖鸡米饭");

    Teacher t;
    t.tech("c++");
    t.eat("新疆大盘鸡");
    return 0;
}



2.关系定性is-a,has-a

is-a

狗是一种动物，动物是狗的基类，狗是动物的派生类。

A是B，B是A的基类，A是B的派生类。为继承关系。


has-a

车有方向盘和轮胎，方向盘和轮胎是车的组成部分。

A包含B，B是A的组成部分。为聚合关系。



2.派生类的声明语法



class Son:public Father
{
public:
    int pub;
    void func()
    {
        x = 3;
        y = 4;
        z = 5;
    }
protected:
    int pro;
private:
    int pri;
};


3.第一个public为继承方式，第二个public为访问权限


继承方式public没有影响 子类的访问方式

影响了父类成员在子类的访问方式：

继承方式为公有继承public：在子类内,public和protected是可以访问的(通过子类函数)，private不可访问(inaccess)；

  ：子类对象(子类外)，只有public的可以访问。

假设father中有三种访问权限pub,pro,pri,在子类中分别为public,protected,inacess


public继承实验代码：

#include <iostream>

using namespace std;

class Father
{
public:
    int x;
protected:
    int y;
private:
    int z;

};

class Son:public Father
{
public:
    int pub;
    void func()
    {
        x = 3;
        y = 4;
//        z = 5;
    }
protected:
    int pro;
private:
    int pri;
};

//
int main()
{
    Son s;
    s.x = 0;
//    s.y = 0;
//    s.z = 0;
    return 0;
}




4.派生类对基类的接收


1.全盘接收，除了构造器与析构器。可能造成派生类成员冗余，基类需要设计；

2.派生类有自己的个性才有意义。


5.派生类构造函数


Graduate::Graduate(string sn, int ia, float fs, double ds)
    :Student(sn,ia,fs),salary(ds)
{

}
class Father
{
public:
    Father(int i){}

};

class Son:public Father
{
public:
    Son():Father(4){}
};



派生类中如果有标配，重载或者默认，派生类中构造函数可以不用显示调用基类的构造器 

class Father
{
public:
    Father(){}

};

class Son:public Father
{
public:
    Son(){}
};


子类只需对父类负责，不需要对父类的父类负责，父类的父类，由父类负责。

class Father
{
public:
    Father(int i){}

};

class Son:public Father
{
public:
    Son(int j):Father(4){}
};

class Grandson:public Son
{
public:
    Grandson():Son(5){}
};


初始化顺序，先对父类初始化，在对类对象进行初始化，再完成本类的构造器 

class A
{
public:
    A() 
    {
        cout<<"A"<<endl;    
    }
};

class Father
{
public:
    Father(int i)
    {
        cout<<"Father"<<endl;    
    }

};

class Son:public Father
{
public:
    Son(int j):Father(4)
    {
        cout<<"Son"<<endl;    
    }
};

class Grandson:public Son
{
public:
    Grandson(int k):Son(5)
    {
        cout<<"Grandson"<<endl;    
    }
    A a;
};

实验代码：

实验代码太长，在此不上传，代码文件名为 InheritSomeFunc




6.

a) 赋值兼容：子类对象(引用或指针)，可以赋给父类对象(引用或指针)


b)子类未实现拷贝构造时，会默认调动父类的拷贝构造器。若子类有拷贝构造器，则必须显示调用父类拷贝构造器(因为继承不会继承构造器)。


c)子类中未实现赋值重载时，会调用父类的赋值重载(无论实现会未实现)。若子类实现了赋值重载，不会主动调用父类的赋值重载。


d) 子类中会把父类重名的成员shadow掉，函数名同即可构成shadow,与参数和返回值无关。


若非重名不可，则必须加上作用域运算符

#include <iostream>

using namespace std;

class Father
{
public:
    void dis()
    {

    }
};

class Son:public Father
{
public:
    void dis()
    {
        /*Father::*/dis();
    }
};

int main()
{
    Son son;
    son.dis();
    return 0;
}


实验代码:

//graduate.h
#ifndef GRADUATE_H
#define GRADUATE_H
#include "student.h"

class Graduate:public Student
{
public:
    Graduate(string sn, int ia, float fs,double ds);
    Graduate(const Graduate &another);
    Graduate& operator =(const Graduate &another);

    void print();
private:
    float salary;
};

#endif // GRADUATE_H

//student.h
#ifndef STUDENT_H
#define STUDENT_H
#include <iostream>
using namespace std;


class Student
{
public:
    Student(string sn,int ia,float score);
    Student(const Student& another);
    Student& operator =(const Student& another);

    void dis();
private:
    string name;
    int age;
    float score;
};

#endif // STUDENT_H
//graduate.cpp
#include "graduate.h"


Graduate::Graduate(string sn, int ia, float fs,double ds)
    :Student(sn,ia,fs),salary(ds)
{

}

Graduate::Graduate(const Graduate &another)
    :Student(another),salary(another.salary)
{

}

Graduate& Graduate::operator =(const Graduate &another)
{
    if(this == &another)
        return *this;
    Student::operator =(another);           //虽然继承父类的重载函数过来了，但由于命名冲突，不
                                            //能直接用，必须加命名空间
    this->salary = another.salary;

    return *this;
}

void Graduate::print()
{
    dis();
    cout<<"salary:"<<salary<<endl;
}

//student.cpp
#include "student.h"
#include <iostream>
using namespace std;

Student::Student(string sn , int ia,float fs)
    :name(sn),age(ia),score(fs)
{

}

Student::Student(const Student& another)
{
    name = another.name;
    age = another.age;
    score = another.score;
}

Student& Student::operator =(const Student& another)
{
    if(this == &another)
        return *this;
    this->name = another.name;
    this->age = another.age;
    this->score = another.score;
}

void Student::dis()
{
    cout<<"name:"<<name<<endl;
    cout<<"age:"<<age<<endl;
    cout<<"score:"<<score<<endl;
}
//main.cpp
#include <iostream>
#include "student.h"
#include "graduate.h"

extern int x=1;
using namespace std;

int main()
{
    Student s("zhaosi",34,150);
    s.dis();

    cout<<"-----------------------"<<endl;

    Graduate g("nengge",35,150,1200);
    g.print();

    cout<<"-----------------------"<<endl;

    Graduate gg("nhoioi",1,1,1);
    gg.print();
    gg = g;
    gg.print();

    return 0;
}









7.派生类析构顺序与构造顺序相反，子类->成员->基类。


#include <iostream>

using namespace std;

class A
{
public:
    A()
    {
        cout<<"A()"<<endl;
    }
    ~A()
    {
        cout<<"~A()"<<endl;
    }
};

class Base
{
public:
    Base()
    {
        cout<<"Base()"<<endl;
    }
    ~Base()
    {
        cout<<"~Base()"<<endl;
    }
};

class Derive:public Base
{
public:
    Derive()
    {
        cout<<"Drive()"<<endl;
    }
    ~Derive()
    {
        cout<<"~Derive()"<<endl;
    }
private:
    A a;
};

int main()
{
    Derive d;
    return 0;
}




8.

overload重载，同一作用域，函数名相同，参数列表不同(个数，类型，顺序)

shadow发生在父子类中，只要函数名相同，即可构成shadow


9.派生类的友元函数


实验代码：

#include <iostream>
using namespace std;


class Student
{
public:
    Student(int a, int b):
        _a(a),_b(b){}
    friend ostream &operator<<(ostream & out, Student & stu);
private:
    int _a;
    int _b;
};

ostream &operator<<(ostream & out, Student & stu)
{
    out<<stu._a<<"--"<<stu._b<<endl;
    return out;
}

class Graduate:public Student
{
public:
    Graduate(int a, int b, int c)
        :Student(a,b),_c(c){}
    friend ostream &operator<<(ostream & out, Graduate & gra);
private:
    int _c;

};

ostream &operator<<(ostream & out, Graduate & gra)
{
    cout<<static_cast<Student&>(gra);
    cout<<gra._c<<endl;

    return out;
}

int main()
{
    Student s(1,2);
    cout<<s;

    Graduate g(3,4,5);
    cout<<g;
}



 

 

 

 

10.继承方式
 

 

 
 
        public      public      public
pub     pub         pub         pub
pro     pro         pro         pro
pri     inaccess    inaccess    inaccess



        protected   protected   protected
pub     pro         pro         pro        
pro     pro         pro         pro
pri     inaccess    inaccess    inaccess    


        private     private     private 
pub     pri         inaccess    inaccess  
pro     pri         inaccess    inaccess         
pri     inaccess    inaccess    inaccess    
 
 
 
 
 

 

 
 
  

 

 
 public  提供接口用(外部可以直接访问)传承了接口，也传承了数据 

 

 
 protected  隐藏数据用(外部只能通过成员函数访问)传承数据 

 

 
 private隐藏数据用(外部只能通过成员函数访问) 既没有传承接口，也没有传承数据 

 

 
 
 

 

 
 
 

 

 
 实验代码： 

 

 
 
 

 

 
 
#include <iostream>

using namespace std;


class Base
{
public:
    int pub;
protected:
    int pro;
private:
    int pri;
};


class Derive:/*public*//*protected*/private Base
{
public:
    void func()
    {
//        pub = 100;
//        pro = 100;
        pub = 100;

    }
};

int main()
{
    Derive d;
//    d.pub = 100;



    return 0;
}

 
 
 
 
 

 

 
 
 

 

 
 
 

 

 
 11.多继承 

 

 
 实验代码： 

 

 
  
 
//bed.h
#ifndef BED_H
#define BED_H
#include <iostream>

using namespace std;

class Bed
{
public:
    Bed();
    void sleep();
};

#endif // BED_H
 
 
//sofa.h
#ifndef SOFA_H
#define SOFA_H
#include <iostream>

using namespace std;

class Sofa
{
public:
    Sofa();
    void sit();
};

#endif // SOFA_H
 
 
//sofabed.h
#ifndef SOFABED_H
#define SOFABED_H
#include "sofa.h"
#include "bed.h"

class SofaBed:public Sofa,public Bed
{
public:
    SofaBed();
};

#endif // SOFABED_H
 
 
//bed.cpp
#include "bed.h"

Bed::Bed()
{

}

void Bed::sleep()
{
    cout<<"go to bed and have a sleep"<<endl;
}

 
 
//sofa.cpp
#include "sofa.h"

Sofa::Sofa()
{

}

void Sofa::sit()
{
    cout<<"have a seat and have a sleep"<<endl;
}
 
 
//sofabed.cpp
#include "sofabed.h"

SofaBed::SofaBed()
{

}
 
 
//main.cpp
#include <iostream>
#include "sofa.h"
#include "bed.h"
#include "sofabed.h"

using namespace std;

int main()
{
    Sofa sf;
    sf.sit();

    Bed bed;
    bed.sleep();

    SofaBed sb;
    sb.sit();
    sb.sleep();



}

 
 
 
 12.虚继承 
 
 
 
 
 将基类中的共同成员提取出来，只保留一份共同成员，在内存中只有基类成员的一份拷贝，被提取出来共同继承的类称为虚基类. 

 

 
 
  
 
 
   
 
 实验代码： 

 

 
 
 
 
//funiture.h
#ifndef FUNITURE_H
#define FUNITURE_H


class Funiture
{
public:
    Funiture(float len, float wi, float we);

    void discript();

protected:
    float len;
    float wid;
    float weight;
};

#endif // FUNITURE_H

 
 
 
  
//bed.h
#ifndef BED_H
#define BED_H
#include <iostream>
#include "funiture.h"

using namespace std;

class Bed:virtual public Funiture
{
public:
    Bed(float len, float wi, float we);
    void sleep();


};

#endif // BED_H
 
  
//sofa.h
#ifndef SOFA_H
#define SOFA_H
#include <iostream>
#include "funiture.h"

using namespace std;

class Sofa:virtual public Funiture
{
public:
    Sofa(float len, float wi, float we);
    void sit();

};

#endif // SOFA_H

 
  
//sofabed.h
#ifndef SOFABED_H
#define SOFABED_H
#include "sofa.h"
#include "bed.h"
#include "funiture.h"

class SofaBed:public Sofa,public Bed
{
public:
    SofaBed(float len, float wi, float we);
};

#endif // SOFABED_H

 
  
//funiture.cpp
#include "funiture.h"
#include <iostream>

using namespace std;

Funiture::Funiture(float len, float wi, float we)
    :len(len),wid(wi),weight(we)
{

}


void Funiture::discript()
{
    cout<<"len = "<<len<<endl;
    cout<<"wid = "<<wid<<endl;
    cout<<"weight = "<<weight<<endl;
}

 
  
//bed.cpp
#include "bed.h"

Bed::Bed(float len, float wi, float we)
    :Funiture(len,wi,we)
{


}

void Bed::sleep()
{
    cout<<"go to bed and have a sleep"<<endl;
}
 
  
//sofa.cpp
#include "sofa.h"

Sofa::Sofa(float len, float wi, float we)
    :Funiture(len,wi,we)
{

}

void Sofa::sit()
{
    cout<<"have a seat and have a sleep"<<endl;
}
 
  
//sofabed.cpp
#include "sofabed.h"

SofaBed::SofaBed(float len, float wi, float we)
    :Funiture(len,wi,we),Bed(len,wi,we),Sofa(len,wi,we)
{

}

 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
  
 
 
 
 
 
 
 

 

 
 
  

 

 
 
  

 

 


                

        

        

    

  


    

      

        

            

              
                
                  全帝
                
              
            

            

                关注
              
            

        

        

          
      

      

            

                专栏目录
          









                



	

		

			

				
					
SOFA——C++项目“hello world”

				
			

			

				

					TianHQ
				

				

					05-22
					
					1024
					
				

			

		

		

			
				
   既安装SOFA后，发现在F:\SOFA_v19.12\source\examples有它自带的已经编译的例子，但其中并没有C++项目，也不包含源码（个人认为是XML写的），运行就是直接在runSofa.exe那个界面点打开那些.scn项目即可，你可以用Qt打开这些.scn项目，发现就是一堆XML代码了。那条蛇就是默认打开的caduceus.scn项目。

   在F:\SOFA_v19.12\source\applications\tutorials这个目录下有几个C++项目的源码，如ChainHyb

			
		

	



                

              
                



	

		

			

				
					
秋招C++开发学习之路day23

				
			

			

				

					weixin_42925054的博客
				

				

					09-19
					
					109
					
				

			

		

		

			
				
day27（大数相乘、哈夫曼树、linux启动过程、B树、B+树。内存拷贝、TCP怎么保证可靠性、面向对象）

大数相乘：模拟乘法运算的过程。
约瑟夫环
哈夫曼树，我们称判定过程最优二叉树为  哈夫曼树。

​​
3.	linux启动过程
主要分为5个阶段：
内核的引导、运行init、系统初始化、建立终端、用户登录系统
4.	B树，是一种平衡的的多路查找树，节点最大的孩子数目称为B树的阶。
一个m...

			
		

	



                


  
              

                


	

		

			

				
					
解决多继承三角问题实例(SofaBed)

				
			

			

				

					寂蝶难双，窃窃思羽.
				

				

					12-10
					
					391
					
				

			

		

		

			
				
主函数：


#include "stdafx.h"
#include <iostream>
using namespace std;

#include "Sofa.h"
#include "Bed.h"
#include "SofaBed.h"


//为解决
//sofabed len wid high  两份数据 冗余
//        discription() 访问问题
...

			
		

	





	

		

			

				
					
C++基础11-类和对象之操作符重载2

				
			

			

				

					weixin_38383877的博客
				

				

					08-12
					
					165
					
				

			

		

		

			
				
总结：

1、等号操作符重载和拷贝构造函数重载一般用在数据成员中需要单独在堆区开辟内存时(指针)
2、new，delete重载内部还是使用malloc和free
3、逗号表达式(,)、或者(||)，且(&&)，条件表达式(?:)具有短路功能。
 但重载后失去此功能，故不建议重载这两个运算符
4、自定义智能指针auto_ptr(在c++11新特性中已经被移除)是一个模板类。...

			
		

	



		

			
		



	

		

			

				
					
一个demo学会c++编程

					
热门推荐

				
			

			

				

					全栈工程师开发手册（原创）https://github.com/tencentmusic/cube-studio
				

				

					08-01
					
					1万+
					
				

			

		

		

			
				
namespace.h

#pragma once  //防止文件被多重包含
#include 
#include   //数据流
#include   //字符串
#include   //异常
#include   //变化参数
#ifndef PI   //如果没有定义PI则定义，否则跳过  避免重复包含
#define PI 3.1415926
#endif
using namespace

			
		

	





	

		

			

				
					
贵州大学在线判题系统-面向对象程序设计-第三次在线作业

				
			

			

				

					weixin_43687510的博客
				

				

					04-18
					
					4048
					
				

			

		

		

			
				
记录学习，或有不足，欢迎参考

第一题 题干：


有两个类Base1和Base2和它们的共同子类Derived。现在Base1、Base2和main函数的代码已经完成。请根据已有的代码完成类Derived的设计。（只需要提交类Derived的代码）



程序的开始部分如下：


#include <iostream>

using namespace std;

class Base1{

    int a;

public:

    Base1(int a):a(a){

      

			
		

	





	

		

			

				
					
C++学习之C++11标准

				
			

			

				

					m0_74316391的博客
				

				

					04-22
					
					1028
					
				

			

		

		

			
				
在2003年C++标准委员会曾经提交了一份技术勘误表(简称TC1)，使得C++03这个名字已经取代了C++98称为C++11之前的最新C++标准名称。不过由于C++03(TC1)主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把两个标准合并称为C++98/03标准。从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准珊珊来迟。接下来我将会以通俗易懂和亲切的话讲解C++11里面处理线程库之外其他重要部分

			
		

	





	

		

			

				
					
嵌入式学习C++ Day7

				
			

			

				

					weixin_51597107的博客
				

				

					02-19
					
					606
					
				

			

		

		

			
				
嵌入式学习C++ Day7
一、思维导图

二、作业




			
		

	





	

		

			

				
					
C++学习之C基础（day1）

				
			

			

				

					10-02
				

			

		

		

			
				
根据给定的学习笔记内容，以下是对C语言基础知识的详细总结及解释：  ### 第四章：语句  #### 4.1 空语句 - **定义**：空语句实际上仅由一个分号 `;` 构成，没有任何实际的操作。 - **示例**：`;` 或者 `int x; ;` ...

			
		

	





	

		

			

				
					
Sams Teach Yourself C++ in One Hour a Day 8th Edition

				
			

			

				

					04-24
				

			

		

		

			
				
《Sams Teach Yourself C++ in One Hour a Day》第八版是一本广受欢迎的C++学习教程，特别适合初学者入门。这本书以英文原版呈现，其中包含丰富的源代码示例，便于读者理解和实践编程概念。相比其他市面上的教程，...

			
		

	





	

		

			

				
					
C++学习day02

				
			

			

				

					qq_69809412的博客
				

				

					05-17
					
					269
					
				

			

		

		

			
				
c++学习的第二天

			
		

	





	

		

			

				
					
Linux嵌入式开发学习 c++:day5

				
			

			

				

					haogewudi666的博客
				

				

					07-17
					
					369
					
				

			

		

		

			
				
【私有继承】

基类的public成员和protected成员被继承后作为派生类的私有成员。

默认的继承是私有继承。

为了保证基类的部分外部接口特征能够在派生类中也存在，就必须在派生类中国重新定义同名的成员函数（重载）。



【保护继承】

基类的public和protected成员都以保护成员的身份出现在派生类中。



保护级别的成员，除了自己的类内可以访问以外，其派生类也可以访问。



【多态】

首先来看面向对象（OOP）的三大特征：

封装wrap：实现细节隐藏，使得代码模块化。把成员..

			
		

	





	

		

			

				
					
C++虚基类

				
			

			

				

					m0_63365801的博客
				

				

					05-06
					
					509
					
				

			

		

		

			
				
题目描述：已知有Grandson类和main函数如下：





class Grandson:public Son1,public Son2{

string grandsonName;

public:

Grandson(string name1,string name2,string name3,string name4):

Father(name1),Son1(name1,name2),Son2(name1,name3),grandsonName(name4){}

void printGran

			
		

	





	

		

			

				
					
多态应用举例2

				
			

			

				

					gacmy的专栏
				

				

					08-25
					
					751
					
				

			

		

		

			
				
#include
class Base{
    public:
        void fun1(){
            this->fun2();//this 基类指针 fun2虚函数 所以是多态 
        }
        virtual void fun2(){
            cout 
        }
};
class Derived:

			
		

	





	

		

			

				
					
第7章：继承与派生

				
			

			

				

					Liyunhao_haoge的博客
				

				

					01-11
					
					487
					
				

			

		

		

			
				
7.1 继承与派生

定义

保持已有特性而构造新类的过程称为继承；在已有类的基础上新增自己的特性而产生新类的过程称为派生；被继承的已有类称为基类（或父类）；派生出的新类称为派生类（或子类）；

源由

继承的目的：实现代码重用

派生的目的：当新的问题出现，原有程序无法解决（或不能完全解决）时，需要对原有程序进行改造；

用法

class 派生类名: 继承方式 基类名

{

成员声明；

}...

			
		

	





	

		

			

				
					
基于ssm的理发店会员管理系统设计与实现.docx

					
最新发布

				
			

			

				

					09-14
				

			

		

		

			
				
基于ssm的理发店会员管理系统设计与实现.docx

			
		

	





	

		

			

				
					
Home-credit海外贷款信贷产品源码/线上贷款产品大全/贷款平台软件源码/海外借贷平台

				
			

			

				

					09-14
				

			

		

		

			
				
测试环境：Linux系统CentOS7.6、宝塔、PHP7.3、MySQL5.6，根目录public，伪静态laravel5，开启ssl证书
语言：中文简体、英文
laravel框架的程序有点多，这个团队估计主要就是搞laravel开发的，基本上全是这个框架。。。
前端：修改网站的默认文档 index.html 为第一个， index.php 改成第二个 ，或者前端访问 index.html，是编译后的
数据库修改：根目录下面（不是public目录）的 .env 文件

			
		

	





	

		

			

				
					
数字听诊器设计-课程设计报告-基于MATLAB

				
			

			

				

					09-14
				

			

		

		

			
				
数字听诊器设计-课程设计报告-基于MATLAB

			
		

	





	

		

			

				
					
python-env-manager.vsix

				
			

			

				

					09-14
				

			

		

		

			
				
python-env-manager.vsix

			
		

	





	

		

			

				
					
C++学习指南：一小时掌握基础

				
			

			

				

					
				

			

		

		

			
				
本书"C++ in One Hour a Day"是由Siddhartha Rao编写的Sams Teach Yourself系列教程，旨在帮助读者以高效的方式学习C++编程语言。本资源提供的是完整高清且带有目录的版本，适合自学C++的初学者使用。  在C++的自学...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值