C++学习day4

已于 2023-10-10 20:58:08 修改
阅读量526 收藏
点赞数 4
文章标签： c++ 学习 开发语言
于 2023-10-10 20:57:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69894626/article/details/133753028
版权

作业：

1> 思维导图

 2> 整理代码

1. 拷贝赋值函数课上代码

//拷贝赋值函数课上代码
#include<iostream>
using namespace std;

//创建类
class Stu
{
private://私有的
    string name;
    int socer;
    int *age;//此处注意用到指针类型
public://共有的
    //无参构造函数（系统默认设置）
    Stu()
    {
        cout << "Stu:: 无参构造函数 " << endl;

    }
    //有参构造函数（自定义，自定义后需要将无参构造函数显性）
    Stu(string n,int s,int a):name(n),socer(s),age(new int (a))//初始化列表
    {
        cout << "Stu:: 有参构造函数" << endl;

    }
    //拷贝构造函数
    Stu(const Stu &other):name(other.name),socer(other.socer),age(new int(*other.age))//此处注意*other.age：因为定义是指针类型所以要去指针指向的内容进行赋值
    {
        cout << "Stu:: 拷贝构造函数" << endl;
    }
    //拷贝赋值函数
    Stu &operator=(const Stu &other) //此处不能用初始化列表因为是赋值操作
    {
        if(this != &other)//给自己赋值多此一举
        {
            name=other.name;
            socer=other.socer;
            age = new int (*other.age);//深拷贝赋值因为有指针防止段错误。。。
        }
        cout << "Stu:: 拷贝赋值函数" << endl;
        //注意返回值是自身引用
        return *this;
    }
    //析构函数
    ~Stu()//会自动调用
    {
        cout << "Stu:: 析构函数" << endl;
    }

};
int main()
{
    Stu s1;//无参构造函数
    Stu s2("王一博",100,23);//有参构造函数
    Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2


    s1=s3;//拷贝赋值
    return 0;
}

 2.匿名对象（用来初始化有名对象）课上代码

void fun(Stu g)//形参接收实参的值==》Stu g=Stu("lisa",120,25)
{

}
int main()
{
    Stu s1;//无参构造函数
    Stu s2("王一博",100,23);//有参构造函数
    Stu s3(s2); //拷贝构造函数====》将s2拷贝给s3==》Stu s3=s2

    //用到匿名对象给有名对象初始化
    Stu s4=Stu("赵云",88,40);
    //给数组初始化
    Stu s[2]={Stu("哪吒",200,40),Stu("张飞",300,30)};//和c中初始化相似
    //匿名对象作为函数实参使用
    fun(Stu("lisa",120,25));


    s1=s3;//拷贝赋值
    return 0;
}

 3.全局函数作友元,课上代码

//友元上课代码（全局函数作友元）
#include <iostream>
using namespace std;
//封装 房间类
class Room
{
    friend void goodfriend(Room &r);//关键字：friend
private://私有的
    string bedroom;//卧室
public://共有的
    string sittingroom;//客厅
public:
    Room()
    {
        //在类内赋值
        bedroom="卧室";
        sittingroom="客厅";
    }
};
//全局函数作友元
void goodfriend(Room &r)
{
    cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
    cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
}

int main()
{
   Room r;
   goodfriend(r);
   return 0;
}

4.成员函数作友元，课上代码

//成员函数作友元
#include <iostream>
using namespace std;
class Room;//需要声明一下，以免下面用到系统不知道报错
//封装好朋友类
class goodfriend
{
private:
    Room *r;//用到指针是因为指针的大小是固定的，而变量的大小不明，系统无法分配空间
public:
    goodfriend();//在类内声明
    void vist();//在类内声明
};

//封装 房间类
class Room
{/*
    friend void goodfriend(Room &r);//关键字：friend*/
    friend void goodfriend::vist();
private://私有的
    string bedroom;//卧室
public://共有的
    string sittingroom;//客厅
public:
    Room()
    {
        //在类内赋值
        bedroom="卧室";
        sittingroom="客厅";
    }
};
//类外实现
goodfriend::goodfriend()
{
    r=new Room;//申请空间
}
void goodfriend::vist()
{
    cout  << "好朋友正在参观" << r->sittingroom << endl;//共有权限访问成功毋庸置疑
    cout << "好朋友正在参观" << r->bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
    //指针需要用->
}





全局函数作友元
//void goodfriend(Room &r)
//{
//    cout << "好朋友正在参观" << r.sittingroom << endl;//共有权限访问成功毋庸置疑
//    cout << "好朋友正在参观" << r.bedroom << endl;//报错原因：私有权限类外不可访问，需要用友元
//}

int main()
{
   Room r;
   //goodfriend(r);
   goodfriend g;
   g.vist();
   return 0;
}

 5.课前热身

int const a; //......
int const *p; //......
int * const p; //
int const * const p; //
const int fun() {}  //该函数是返回一个常整型变量

 6.常成员函数&&非常成员函数

1.非常对象可以调用常成员函数，也可以调用非常成员函数，优先调用非常成员函数

2.常对象只能调用常成员函数，如果没有常成员函数，则报错

#include <iostream>
using namespace std;
class Stu
{
private:
    string name;//只对该成员变量在常成员函数中可以被修改mutable
    int id;
public:
    Stu(){}
    Stu(string name,int id):name(name),id(id)
    {}
    //常成员函数
    void display()const //==》Stu const * const this;表示指针的值和指向都不可改
    {
        //this ->name ="li si";报错原因：因为被const修饰不可以更改
        cout << name << " " << id <<endl;
    }
    //非常成员函数
    void display()//==>Stu * const this;和常成员重载
    {
        this -> name ="lisi";
        cout << name << " " << id << endl;
    }

};

int main()
{
    cout << "Hello World!" << endl;
    const Stu s1("zhangsan",1001);//常对象
    s1.display();//常对象只能调用常成员函数
    return 0;
}

 7.成员函数来实现运算符重载

//运算符重载
#include<iostream>
using namespace std;

//构造类
class Club
{
private://私有的
    int age;
    int hight;
public:
    //无参
    Club(){}
    Club(int a,int h):age(a),hight(h)
    {

    }
    //成员函数实现算数运算符重载 加法
    const Club operator+(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age+R.age;
        temp.hight=hight+R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 减法
    const Club operator-(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age-R.age;
        temp.hight=hight-R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 乘法
    const Club operator*(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age*R.age;
        temp.hight=hight*R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 除法
    const Club operator/(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age/R.age;
        temp.hight=hight/R.hight;

        return temp;
    }
    //成员函数实现算数运算符重载 取余
    const Club operator%(const Club &R)const//const 1：结果 2：右操作数 3：左操作数
    {
        //内部运算
        Club temp;
        temp.age=age%R.age;
        temp.hight=hight%R.hight;

        return temp;
    }
关系运算符//
    //成员函数实现关系运算符重载 >
    bool operator>(const Club &R)const
    {
        if(age>R.age && hight>R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 <
    bool operator<(const Club &R)const
    {
        if(age<R.age && hight<R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 >=
    bool operator>=(const Club &R)const
    {
        if(age>=R.age && hight>=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 <=
    bool operator<=(const Club &R)const
    {
        if(age<=R.age && hight<=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //成员函数实现关系运算符重载 ==
    bool operator==(const Club &R)const
    {
        if(age==R.age && hight==R.hight)
        {
            return true;
        }
        else
            return false;
    }
 
    //成员函数实现关系运算符重载 >
    bool operator!=(const Club &R)const
    {
        if(age!=R.age && hight!=R.hight)
        {
            return true;
        }
        else
            return false;
    }
    //赋值运算符
    //成员函数实现赋值运算符重载 +=
   Club &operator+=(const Club &R)
    {
        age += R.age;
        hight += R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 -=
   Club &operator-=(const Club &R)
    {
        age -= R.age;
        hight -= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 =
   Club &operator=(const Club &R)
    {
        age = R.age;
        hight = R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 *=
   Club &operator*=(const Club &R)
    {
        age *= R.age;
        hight *= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 /=
   Club &operator/=(const Club &R)
    {
        age /= R.age;
        hight /= R.hight;
        return *this;//返回自身
    }
   //成员函数实现赋值运算符重载 %=
   Club &operator%=(const Club &R)
    {
        age %= R.age;
        hight %= R.hight;
        return *this;//返回自身
    }



    void show()
    {
        cout << "age= " << age << " " << "hight= " << hight << endl;
    }
};
int main()
{
    Club c1(10,10);
    Club c2(10,10);


    Club c3=c1+c2;
    Club c4=c1-c2;
    Club c5=c1*c1;
    Club c6=c1/c2;
    Club c7=c1%c2;

    cout << "算数运算符" << endl;
    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();

    cout << "关系运算符" << endl;

    if(c3!=c1)
    {
        if(c3>c1)
        {
            cout << "c3>c1 " << endl;
        }
        else if(c3<c1)
        {
            cout << "c3<c1 " << endl;
        }
        cout << "c3!=c1" << endl;

    }
    else if(c3 == c1)
    {

         if(c3>=c1)
        {
            cout << "c3>=c1" << endl;
        }
        else if(c3<=c1)
        {
            cout << "c3<=c1" << endl;
        }

        {
            cout << "c3==c1" << endl;

        }

    }

    cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    c3+=c2;
    c4-=c2;
    c5*=c1;
    c6/=c2;
    c7%=c2;

    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();


    return  0;
}

效果图:

 8.全局函数实现运算符重载

//运算符重载
#include<iostream>
using namespace std;

//构造类
class Club
{
    friend const Club operator+(const Club &L,const Club &R);
    friend const Club operator-(const Club &L,const Club &R);
    friend const Club operator*(const Club &L,const Club &R);
    friend const Club operator/(const Club &L,const Club &R);
    friend const Club operator%(const Club &L,const Club &R);
    friend bool operator>(const Club &L,const Club &R);
    friend bool operator<(const Club &L,const Club &R);
    friend bool operator<=(const Club &L,const Club &R);
    friend bool operator>=(const Club &L,const Club &R);
    friend bool operator==(const Club &L,const Club &R);
    friend bool operator!=(const Club &L,const Club &R);
    friend Club &operator+=( Club &L,const Club &R);
    friend Club &operator-=( Club &L,const Club &R);
   
    friend Club &operator*=( Club &L,const Club &R);
    friend Club &operator/=(Club &L,const Club &R);
    friend Club &operator%=( Club &L,const Club &R);
    
private://私有的
    int age;
    int hight;
public:
    //无参
    Club(){}
    Club(int a,int h):age(a),hight(h)
    {
        
    }
    
    void show()
    {
        cout << "age= " << age << " " << "hight= " << hight << endl;
    }
};
//成员函数实现算数运算符重载 加法
const Club operator+(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age-R.age;
    temp.hight=L.hight-R.hight;

    return temp;
}
   
//成员函数实现算数运算符重载 减法
const Club operator-(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age-R.age;
    temp.hight=L.hight-R.hight;

    return temp;
}

//成员函数实现算数运算符重载 乘法
const Club operator*(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age*R.age;
    temp.hight=L.hight*R.hight;

    return temp;
}
//成员函数实现算数运算符重载 除法
const Club operator/(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age/R.age;
    temp.hight=L.hight/R.hight;

    return temp;
}
//成员函数实现算数运算符重载 取余
const Club operator%(const Club &L,const Club &R)//const 1：结果 2：右操作数 3：左操作数
{
    //内部运算
    Club temp;
    temp.age=L.age%R.age;
    temp.hight=L.hight%R.hight;

    return temp;
}
关系运算符//
//成员函数实现关系运算符重载 >
bool operator>(const Club &L,const Club &R)
{
    if(L.age>R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 <
bool operator<(const Club &L,const Club &R)
{
    if(L.age>R.age && L.hight<R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 >=
bool operator>=(const Club &L,const Club &R)
{
    if(L.age>=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 <=
bool operator<=(const Club &L,const Club &R)
{
    if(L.age<=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//成员函数实现关系运算符重载 ==
bool operator==(const Club &L,const Club &R)
{
    if(L.age==R.age && L.hight==R.hight)
    {
        return true;
    }
    else
        return false;
}

//成员函数实现关系运算符重载 !=
bool operator!=(const Club &L,const Club &R)
{
    if(L.age!=R.age && L.hight>R.hight)
    {
        return true;
    }
    else
        return false;
}
//赋值运算符
//成员函数实现赋值运算符重载 +=
Club &operator+=( Club &L,const Club &R)
{
    L.age += R.age;
    L.hight += R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 -=
Club &operator-=( Club &L,const Club &R)
{
    L.age -= R.age;
    L.hight -= R.hight;
    return L;//返回自身
}

//成员函数实现赋值运算符重载 *=
Club &operator*=( Club &L,const Club &R)
{
    L.age *= R.age;
    L.hight *= R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 /=
Club &operator/=( Club &L,const Club &R)
{
    L.age /= R.age;
    L.hight /= R.hight;
    return L;//返回自身
}
//成员函数实现赋值运算符重载 %=
Club &operator%=(Club &L,const Club &R)
{
    L.age /= R.age;
    L.hight /= R.hight;
    return L;//返回自身
}


int main()
{
    Club c1(10,10);
    Club c2(10,10);


    Club c3=c1+c2;
    Club c4=c1-c2;
    Club c5=c1*c1;
    Club c6=c1/c2;
    Club c7=c1%c2;

    cout << "算数运算符" << endl;
    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();

    cout << "关系运算符" << endl;

    if(c3!=c1)
    {
        if(c3>c1)
        {
            cout << "c3>c1 " << endl;
        }
        else if(c3<c1)
        {
            cout << "c3<c1 " << endl;
        }
        cout << "c3!=c1" << endl;

    }
    else if(c3 == c1)
    {

         if(c3>=c1)
        {
            cout << "c3>=c1" << endl;
        }
        else if(c3<=c1)
        {
            cout << "c3<=c1" << endl;
        }

        {
            cout << "c3==c1" << endl;

        }

    }

    cout << "赋值运算符" << endl;//赋值函数不要加类型否则属于初始化会报错
    c3+=c2;
    c4-=c2;
    c5*=c1;
    c6/=c2;
    c7%=c2;

    c3.show();
    c4.show();
    c5.show();
    c6.show();
    c7.show();


    return  0;
}

代码不会敲！
关注
C++学习day02
qq_69809412的博客
05-17 275
c++学习的第二天
C++学习day08 ：lambda和异常捕获
qq_69809412的博客
05-24 442
C++学习第8天lambda的用法和异常捕获
C++中常对象、常成员函数、常成员变量
隋森的博客
02-14 2913
用const修饰的类对象叫做常对象， 用const修饰的成员函数叫常成员函数， 用const修饰的成员变量叫常成员变量， 常对象： 型如：      const  &lt;类名&gt;  &lt;对象名&gt;      &lt;类名&gt;  const  &lt;对象名&gt; 说明： 1.常对象内的成员变量值不可修改，所以一定要在定义对象时初始化。 2.常对象只可以调用常成...
猿创征文 |【C++】面向对象之微观部分——类的组成(中)
m0_65835264的博客
09-09 1439
本文【C++】面向对象之微观部分——类的组成(中) 主要讲述了C++中面向对象之类的常对象与常函数，类中静态成员函数，拷贝构造与深浅拷贝。以详细的代码示例通俗易懂的将知识呈现给阅读者。本文是一个系列，感兴趣可以先点个关注，希望本文对您有所帮助。...
C++调用成员函数的几种方法总结
最新发布
jingbeng11
04-08 1万+
【代码】C++调用成员函数的几种方法总结。
C++PTA判断选择整理（第六章到12章）
qq_52551375的博客
06-27 3216
1.对静态数据成员初始化可以在类内进行。（F） 2.静态数据成员不属于某个对象，在给对象分配存储空间时，不包括静态数据成员所占的空间。（T） 3.静态成员函数属于类而不是类的对象，没有this指针，静态成员函数中不能使用this指针。（T） 4.静态成员函数的实现必须在类体外实现，不能在类体内实现。（F） 5.由于静态成员函数不属于某个特定的对象，因此。不能像一般的成员函数那样随意的访问对象中的非静态数据成员。只能引用类中声明的静态数据成员。如果要引用非静态数据成员，可通过对象引用。（T） 6.常数据成员的
非常对象访问常成员函数，导致内部this指针无法访问非常成员函数
梦想博客
10-20 2498
非常对象访问常成员函数，导致内部this指针无法访问非常成员函数,引发如下异常： rror C2662: “LinkedList::showElement”: 不能将“this”指针从“const LinkedList”转换为“LinkedList &”  实例如下： class LinkedList { private: public: void showElem
C++学习day05 vector容器和string容器
qq_69809412的博客
05-20 231
C++学习第五天C++学习day05 vector容器和string容器
Linux嵌入式开发学习 c++:day5
haogewudi666的博客
07-17 378
【私有继承】 基类的public成员和protected成员被继承后作为派生类的私有成员。 默认的继承是私有继承。 为了保证基类的部分外部接口特征能够在派生类中也存在，就必须在派生类中国重新定义同名的成员函数（重载）。 【保护继承】 基类的public和protected成员都以保护成员的身份出现在派生类中。 保护级别的成员，除了自己的类内可以访问以外，其派生类也可以访问。 【多态】 首先来看面向对象（OOP）的三大特征： 封装wrap：实现细节隐藏，使得代码模块化。把成员..
C++学习之C基础（day1）
10-02
根据给定的学习笔记内容，以下是对C语言基础知识的详细总结及解释： ### 第四章：语句 #### 4.1 空语句 - **定义**：空语句实际上仅由一个分号 `;` 构成，没有任何实际的操作。 - **示例**：`;` 或者 `int x; ;` ...
成员函数的选择调用一一常成员函数 (12 分)
Mr123zhangchao的博客
04-21 1043
成员函数的选择调用一一常成员函数 (12 分) 类中的常对象选择调用常成员函数。语法要点: 如果将一个对象说明为常对象，则通过该常对象只能调用它的常成员函数, 而不能调用其他成员函数。补充完整复数类的定义 （复数类Complex,数据成员：构造函数，以常成员函数重载的输出函数。数据成员有实部与虚部） 使得程序的输出结果符合题意的输出结果。 class Complex { public: /补充完整类的定义/ /***********************************/ /...
怎样利用常成员函数？
Panda的专栏
06-22 1551
<br /><br />(1) 如果在一个类中，有些数据成员的值允许改变，另一些数据成员的值不允许改变，则可以将一部分数据成员声明为const，以保证其值不被改变，可以用非const的成员函数引用这些数据成员的值，并修改非const数据成员的值。<br />(2) 如果要求所有的数据成员的值都不允许改变，则可以将所有的数据成员声明为const，或将对象声明为const(常对象)，然后用const成员函数引用数据成员，这样起到“双保险”的作用，切实保证了数据成员不被修改。<br />(3) 如果已定义了一个常
c++ 常成员函数 和 常对象
UnrealEngine4 、Delta3D、OSG
06-17 1万+
先明确几个概念： 1. 常对象只能调用常成员函数。 2. 普通对象可以调用全部成员函数。
共享数据保护
qq_62845624的博客
04-01 620
为了是数据可以被共享但是又不会被随意的修改，我们使用const来进行数据保护。 1.用const修饰的数据成员称为常数据成员 2.用const修饰的成员函数称为常成员函数 3.用const修饰的对象叫常对象 （1）常数据成员 两种声名方式： 1.const int x； 2.int const x； 注意： （1）任意函数不能对常数据成员进行赋值。 （2） 构造函数队常数据成员进行初始化时只能通过初始化列表进行。 （3如果类有多个构造函数，那么每个构造函数都要对常数据成员进行初
常引用，常对象，常成员函数，常数据成员~
qq_37385726的博客
04-29 3062
①常引用 形式—— const 类型 &对象名或变量名 ②常对象 形式——const 类名 对象名 1.常对象的数据成员不能被修改了，在定义的时候应该对其进行初始化 2.常对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型，这是不安全的。 3.常对象可以调用静态成员函数，常成员函数，其实也可以调友元函数  （但是这里不对每一个具体展开了，就只是为了更加明白常对象是不
C++常对象，常变量，常成员函数详解（含添加内容）
E_ROAD_BY_U的博客
08-15 1万+
·        用const修饰的声明数据成员称为常数据成员 ·        用const修饰的声明成员函数称为常成员函数 ·        用const修饰的定义对象称为常对象 变量或对象被const修饰后其值不能被更新。因此被const修饰的变量或对象必须要进行初始化。 （一）用const修饰的声明数据成员称为常数据成员     有两种声明形式： const int  cctw
常成员函数只能调用常成员函数 常对象智能调用常成员函数
lujiandong1的专栏
12-04 5319
class A { public:  void print()const{ cout void test() { print();} void test1() const {print();}   }; int main(int argc, char* argv[]) {  A a; a.print(); a.test(); a.test1();    return
常对象 常成员函数 的关系
zhuzongwei1988的专栏
04-14 521
#ifndef CHAP_7_H#define CHAP_7_H#include "iostream"using namespace std;class A{public: A(); void test(); void const_test(); void const_test() const;private: int x; const int y;};A::A():y(10),x(20){ co
关于常成员函数对非常成员函数的调用问题
JTR502的博客
05-14 4962
常成员函数不能调用非常成员函数：比如：#include&lt;iostream&gt; using namespace std; class A { const void print(){cout&lt;&lt;fun();} }; int fun() { return 2; } int main() { A.a; a.print(); return 0; }程序报错无法运行...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值