C++ primer第6版 12章课后题

最新推荐文章于 2021-09-02 19:26:03 发布
最新推荐文章于 2021-09-02 19:26:03 发布
阅读量492 收藏
点赞数
分类专栏： 重读C++primer 文章标签： C++ 类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiaomimi1993/article/details/81631224
版权

12.1 对于下面的类声明：

class Cow{
    char name[20];
    char* hobby;
    double weight;
public:
    Cow();
    Cow(const char* nm, const char* ho, double wt);
    Cow(const Cow &c);
    ~Cow();
    Cow& operator=(const Cow& c);
    void ShowCow() const; //display all cow data    
};

给这个类提供实现，并编写一个使用所有类成员函数的小程序。

class Cow{
    char name[20];
    char* hobby;
    double weight;
public:
    Cow();
    Cow(const char* nm, const char* ho, double wt);
    Cow(const Cow &c);
    ~Cow();
    Cow& operator=(const Cow& c);
    void ShowCow() const; //display all cow data
};

Cow::Cow(){
    name[0] = '\0';
    hobby = new char[1];
    weight = 0.0;
}

Cow::Cow(const char* nm, const char* ho, double wt){
    strcpy(name, nm);
    hobby = new char[strlen(ho)+1];
    strcpy(hobby, ho);
    weight = wt;
}

Cow::Cow(const Cow &c){
    strcpy(name, c.name);
    hobby = new char(strlen(c.hobby)+1);
    strcpy(hobby, c.hobby);
    weight = c.weight;
}

Cow::~Cow(){
    delete []hobby;
}

Cow& Cow::operator=(const Cow& c){
    if(this == &c){
        return *this;
    }
    delete []hobby;
    hobby = new  char(strlen(c.hobby+1));
    strcpy(name, c.name);
    strcpy(hobby, c.hobby);
    weight = c.weight;
    return  *this;
}

void Cow::ShowCow() const{
    cout<<"Name = "<<name<<endl<<"Hobby: "<<hobby<<endl<<"Weight: "<<weight<<endl;
}

2.通过完成下面的工作来改进String类声明：
a.对+运算符进行重载，使之可将两个字符串合并成1个
b.提供一个Stringlow()成员函数，将字符串中所有的字母字符转换为小写（别忘了存储type系列字符函数）。
c.提供String()成员函数，将字符串中所有字母字符转换成大写。
d.提供一个这样的成员函数，它接受一个char参数，返回该字符在字符串中出现的次数
头文件

//
//  string1.h
//  12.2
//
//  Created by apple on 2018/8/13.
//  Copyright © 2018年 apple. All rights reserved.
//

#ifndef string1_h
#define string1_h
#include <iostream>
using namespace std;

class String {
private:
    char* str;
    int len;
    static int num_strings;//number of objects
    static const int CINLIM = 80; //cin input limits
public:

    String(const char* s);
    String();//default constructor
    String(const String &);//copy constructor
    ~String();
    int length()const{return len;}
    //overloaded operator methods
    String& operator=(const String &);
    String& operator=(const char*);
    String operator+(const String &)const;//merge
    String operator+(const char*);//merge
    char& operator[](int i);
    const char& operator[](int i) const;
    //overloaded operator friends
    friend bool operator<(const String &st, const String &str2);
    friend bool operator>(const String &st, const String &str2);
    friend bool operator==(const String &st, const String &str2);
    friend ostream & operator<<(ostream &os, const String &str);
    friend istream & operator>>(istream &is, const String &str);
    friend String operator+(char *st, const String&s);
    //static function
    static int HowMany();

    String stringlow();
    String stringup();
    int has(char );
};

#endif /* string1_h */

头文件实现文件

//
//  string1.cpp
//  12.2
//
//  Created by apple on 2018/8/13.
//  Copyright © 2018年 apple. All rights reserved.
//

#include <stdio.h>
#include "string1.h"
using namespace std;

int String::num_strings = 0;
String::String(const char* s){
    len = strlen(s);//set size
    str = new char(len);//allot storage
    strcpy(str,s);//initialize pointer
    num_strings++;//set object count
}

String::String(){
    //default constructor
    len = 4;
    str = new char[1];
    str[0] = '\0'; //default string;
    num_strings++;
}
String::String(const String &st){
    //copy constructor
    num_strings++;
    len = st.len;//same length
    str = new char(len + 1);//allot space
    strcpy(str, st.str);//copy string to new location
}
String::~String(){
    --num_strings;
    delete []str;
}

//overloaded operator methods
String& String::operator=(const String &st){
    if(this == &st)
        return *this;
    delete []str;
    len = st.len;
    str = new char[len+1];
    strcpy(str, st.str);
    return *this;

}
String& String::operator=(const char*s){
    delete []str;
    len = strlen(s);
    str = new char[len+1];
    strcpy(str,s);
    return *this;
}
char& String::operator[](int i){
    return str[i];
}
const char& String::operator[](int i) const{
    return str[i];
}
//overloaded operator friends
bool operator<(const String &st, const String &str2){
    return (strcmp(st.str, str2.str)<0);
}
bool operator>(const String &st, const String &str2){
    return (strcmp(st.str, str2.str)>0);
}
bool operator==(const String &st, const String &str2){
    return (strcmp(st.str, str2.str)== 0);
}
ostream & operator<<(ostream &os, const String &st){
    os<<st.str;
    return os;
}
istream & operator>>(istream & is, String & st){
    char tmp[String::CINLIM];
    is.get(tmp, String::CINLIM);
    if(is)
        st = tmp;
    while (is && is.get()!='\n')
        continue;
    return is;
}
//static function
int String::HowMany(){
    return num_strings;
}

String String::operator+(const String &st)const{
    String temp;
    temp.len = len + st.len;
    delete []temp.str;
    temp.str = new char[temp.len+1];
    strcpy(temp.str, str);
    strcat(temp.str, st.str);
    return temp;
}
String String::operator+(const char*s){
    String temp;
    temp.len = len + strlen(s);
    delete []temp.str;
    temp.str = new char[temp.len+1];
    strcpy(temp.str, str);
    strcat(temp.str, s);
    return temp;
}

String String::stringlow(){
    int i = 0;
    while (i < len) {
        str[i++] = tolower(str[i]);
    }
    return *this;
}

String String::stringup(){
    int i = 0;
    while (i < len) {
        str[i++] = toupper(str[i]);
    }
    return *this;
}

int String::has(char a){
    int count = 0;
    for(int i =0 ; i < len; i++){
        if(str[i] == a)
            count++;
    }
    return count;
}

String operator+(char *st, const String&s){
    String temp;
    temp.len = strlen(st) + s.len;
    delete []temp.str;
    temp.str = new char[temp.len+1];
    strcpy(temp.str, st);
    strcat(temp.str, s.str);
    return temp;
}

测试文件

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

const int ArSize = 10;
const int MaxLen = 81;
int main(){
    String s1("and I am a C++ Student.");
    String s2 = "Please enter your name:";
    String s3 = "cin mei xie hao";
    cout<<s2;//overload << operator
 //   cin>>s3;//overload >> operator
    s2 = "My name is " + s3; // overloaded =, + operators
    cout<< s2<<".\n";
    s2 = s2+s1;
    s2.stringup(); //converts string to uppercase
    cout<<"The string\n"<<s2<<"\ncontains "<<s2.has('A')<<" 'A' characters in it.\n";
    s1 = "red";
    String rgb[3] = {String(s1), String("green"), String("blue")};
    cout<<"Enter the name of a primary color for mixing light: ";
    String ans;
    bool success = false;
    while(cin>>ans){
        ans.stringlow();
        for(int i = 0; i < 3; i++){
            if(ans == rgb[i]){
                cout<<"That's right\n";
                success = true;
                break;
            }
        }
        if(success)
            break;
        else
            cout<<"Try again!\n";
    }
    cout<<"Bye\n";
    return 0;
}

3.新编写程序清单10.7和程序清单10.8描述的Stock类，使之使用动态分配的内存，而不是string类对象来存储股票名称。另外，使用重载的operator<<()定义代替show()成员函数，再使用程序清单10.9测试新的定义程序。
头文件

//
//  Stock.h
//  12.3
//
//  Created by apple on 2018/8/13.
//  Copyright © 2018年 apple. All rights reserved.
//

#ifndef Stock_h
#define Stock_h
#include <string>

class Stock{
private:
    char *company;
    int shares;
    double shared_val;
    double total_val;
    void set_tot(){
        total_val = shares*shared_val;
    }
public:
    Stock();
    Stock(const char *, long n = 0, double pr = 0.0);
    ~Stock();
    void buy(long num, double price);
    void sell(long num, double price);
    void update(double price);
 //   void show()const;
    friend std::ostream & operator <<(std::ostream &os, const Stock &s);
    const Stock& topval(const Stock &s) const;
};

#endif /* Stock_h */

头文件实现文件

//
//  Stock.cpp
//  12.3
//
//  Created by apple on 2018/8/13.
//  Copyright © 2018年 apple. All rights reserved.
//

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

Stock::Stock(){
    company = new char[8];
    char *s = "no name";
    strcpy(company, s);
    shares = 0;
    shared_val = 0.0;
    total_val = 0.0;
}

Stock::Stock(const char *s, long n , double pr ){
    int len = strlen(s);
    company = new char[len+1];
    strcpy(company, s);
    if(n < 0){
        cout<<"Number of shares can't be negative; "<<company<<" shares set to 0.\n";
        shares = 0;
    }
    else
        shares = n;
    shared_val = pr;
    set_tot();
}
Stock::~Stock(){
    delete []company;
}
void Stock::buy(long num, double price){
    if(num < 0){
        cout<<"Number of shares purchased can't be negative. "<<"Transaction is aborted.\n";
    }
    else{
        shares += num;
        shared_val = price;
        set_tot();
    }
}

void Stock::sell(long num, double price){
    if(num < 0){
        cout<<"Number of shares sold can't be negative. Transaction is aborted.\n";
    }
    else if(num >  shares){
        cout<<"You can't sell more than you have ! Transaction is aborted.\n";
    }
    else{
        shares -= num;
        shared_val = price;
        set_tot();
    }
}

void Stock::update(double price){
    shared_val = price;
    set_tot();
}
/*void Stock::show()const{
    //set format to #.###
    ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
    streamsize prec = cout.precision(3);
    cout<<"Company: "<<company<<" Shares: "<<shares<<'\n';
    cout<<" Share Price: $"<<shared_val;
    //set format to #.##
    cout.precision(2);
    cout<<" Total Worth: $"<<total_val<<'\n';

    //restore original format
    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
}*/
std::ostream & operator <<(std::ostream &os, const Stock &s){
    //set format to #.###
    ios_base::fmtflags orig = cout.setf(ios_base::fixed, ios_base::floatfield);
    streamsize prec = cout.precision(3);
    cout<<"Company: "<<s.company<<" Shares: "<<s.shares<<'\n';
    cout<<" Share Price: $"<<s.shared_val;
    //set format to #.##
    cout.precision(2);
    cout<<" Total Worth: $"<<s.total_val<<'\n';

    //restore original format
    cout.setf(orig, ios_base::floatfield);
    cout.precision(prec);
    return os;
}

const Stock& Stock::topval(const Stock &s) const{
    if(s.total_val > total_val){
        return s;
    }
    else
        return *this;
}

测试文件

//
//  main.cpp
//  12.3
//
//  Created by apple on 2018/8/13.
//  Copyright © 2018年 apple. All rights reserved.
//

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

const int STKS = 4;

int main(int argc, const char * argv[]) {
    Stock stocks[STKS] = {
        Stock("NanoSmart", 12, 20.0),
        Stock("Boffo Objects", 200, 2.0),
        Stock("Monolithic Obelisks", 130, 3.25),
        Stock("Fleep Enterprises", 60, 6.5)
    };
    cout<<"Stock holding:\n";
    int st;
    for(st = 0; st < STKS; st++){
       // stocks[st].show();
        cout<<stocks[st];
    }
    const Stock *top = &stocks[0];
    for(st = 1; st < STKS; st++){
        top = &top->topval(stocks[st]);
    }
    cout<<"\n Most valuable holding:\n";
   // top->show();
    cout<<*top;
    return 0;
}

4.

//
//  main.cpp
//  12.4
//
//  Created by apple on 2018/8/14.
//  Copyright © 2018年 apple. All rights reserved.
//

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

int main(int argc, const char * argv[]) {
    Stack st1(10);
    srand(time(0));
    for(size_t i = 0; i < 10; i++){
        if(!st1.push(rand()%100)){
            cout<<"Push error!"<<endl;
        }
    }
    if(!st1.push(0)){
        cout<<"Push 0 error!"<<endl;
    }
    Stack st2(st1);
    Stack st3 = st1;
    //故意设置pop error
    for(size_t i = 0; i < 11; i++){
        Item item;
        cout<<"#"<<i+1<<": "<<endl;
        if(!st1.pop(item)){
            cout<<"st1 pop error! "<<endl;
        }
        else{
            cout<<"st1: "<<item<<endl;
        }
        if(!st2.pop(item)){
            cout<<"st2 pop error!"<<endl;
        }
        else{
            cout<<"st2: "<<item<<endl;
        }
        if(!st3.pop(item)){
            cout<<"st3 pop error!"<<endl;
        }
        else
            cout<<"st3: "<<item <<endl;
    }
    return 0;
}

6.Heather银行想知道，如果再开设一台ATM，情况将如何。请对模拟进行修改，以包含两个队列。假设当第一台ATM前的排队人数少于第二台ATM时，客户讲排在第一队，否则将排在第二队。然后再找出要使品骏等候时间为1分钟，每小时到达的客户数应该为多少?

//
//  main.cpp
//  12.5
//
//  Created by apple on 2018/8/14.
//  Copyright © 2018年 apple. All rights reserved.
//

#include <iostream>
#include "queue.h"
const int MIN_PER_HR = 60;
bool newcustomer(double x);
using namespace std;

int main(int argc, const char * argv[]) {
    srand(time(0));//random initializing of rand()
    cout<<"Case Study: Bank of Heather Automatic Teller.\n";
    cout<<"Enter maximum size of queue: ";
    int qs;
    cin>>qs;
    Queue line1(qs);
    Queue line2(qs);
    cout<<"Enter the number of simulation hours: ";
    int hours;
    cin>>hours;
    //simulation will run 1 cycle per minute
    long cyclelimit = MIN_PER_HR * hours;

    cout<<"Enter the average number of customers per hour: ";
    double perhour;
    cin>>perhour;
    double min_per_cust;
    min_per_cust = MIN_PER_HR;

    Item temp; // new customer data
    long turnaways = 0; //turned away by full queue
    long cusstomers = 0; //joined the queue
    long served = 0; //served during the simulation
    long sum_line = 0; //cumulative line length
    int wait_time1 = 0; //time until autoteller is free
    int wait_time2 = 0;
    long line_wait = 0; //cumulative time in line
    //running the simulation
    for(int cycle = 0; cycle < cyclelimit; cycle++){
        if(newcustomer(min_per_cust)){
            if(line1.isfull() && line2.isfull())
                turnaways++;
            else{
                cusstomers++;
                temp.set(cycle);
                if(line1.queuecount() < line2.queuecount()){
                    line1.enqueue(temp);
                }
                else{
                    line2.enqueue(temp);
                }

            }
        }
        if(wait_time1 <= 0 && !line1.isempty()){
            line1.dequeue(temp);
            wait_time1 = temp.ptime();
            line_wait += cyclelimit - temp.when();
            served++;
        }
        if(wait_time2 <= 0 && !line2.isempty()){
            line2.dequeue(temp);
            wait_time2 = temp.ptime();
            line_wait += cyclelimit - temp.when();
            served++;
        }
        if(wait_time1 > 0)
            wait_time1--;
        if(wait_time2 > 0)
            wait_time2--;
        sum_line += (line1.queuecount() + line2.queuecount())/2;
    }
    //reporting results
    if(cusstomers > 0){
        cout<<"customers accepted: "<<cusstomers<<endl;
        cout<<" customers served: "<<served<<endl;
        cout<<"     turnaways: "<<turnaways<<endl;
        cout<<"average queue size: ";
        cout.precision(2);
        cout.setf(ios_base::fixed, ios_base::floatfield);
        cout<<(double) sum_line / cyclelimit << endl;
        cout<<" average wait time: "<<(double) line_wait / served << " minutes\n";
    }
    else{
        cout<<"No customers!\n";
    }
    cout<<"Done!\n";
    return 0;
}

bool newcustomer(double x){
    return (std::rand() * x / RAND_MAX < 1);
}
求offer呀
关注
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 33万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
c++primer plus 第12章习题
chinahnwqf的博客
05-20 504
//第12章第1题 #ifndef STACK_H #define STACK_H #define _CRT_SECURE_NO_WARNINGS class Cow { private: char name[20]; char *hobby; double weight; public: Cow(); Cow(const char *nm, const char * ho, doubl
C++primer 练习6.2.6
hello_jcc的博客
04-28 238
练习6.27 //计算列表所有的和 #include <iostream> using namespace std; int add_int(initializer_list<int>list) { int add_num=0; for (auto const &num : list) { add_num = num + ad...
C++ primer 6.2.6 含有可变形参的函数
jnjejnx的博客
03-16 138
C++有一种特殊的形参类型(即省略符)，可以用它传递可变数量的形参，这种功能一般用于与C函数交互的接口程序。 initializer_list 形参 如果实参数量未知，但全部实参类型相同，就可以使用initializer_list类型的形参（使用时需包含同名头文件） 定义initializer_list对象时，必须说明列表中所含元素的类型 例如 initializer_list<string>lst;//initializer_list的元素是string类型 initializer_li
C++ Primer Plus第六版编程题（第12章）
vmxhc1314的博客
01-18 871
C++ Primer Plus第六版编程题（第12章）题目程序 题目 1.对于下面的类声明： （……代码忽略……） 给这个类提供实现，并编写一个使用所有成员函数的小程序。 2.通过完成下面的工作来改进String类声明（即将String1.h升级为String2.h）。 a. 对+运算符进行重载，使之可将两个字符串合并成1个。 b. 提供一个Stringlow()成员函数，将字符串中所有的字...
《C++ Primer Plus（第六版）》（24）（第十二章 类和动态内存分配 编程题和答案）...
weixin_30336061的博客
12-26 242
1.对于下面的类声明： class Cow { private: char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char* ho, double w...
C++ Primer Plus 第6版 中文版课后代码习题答案
最新发布
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
C++Primer（第4版）-课后习题答案.pdf
11-01
12. 第十二章类和数据抽象：讲解面向对象编程的核心概念，如类的定义、封装、构造函数、成员函数、友元等。 13. 第十三章复制控制：探讨对象的创建、复制和销毁，包括拷贝构造函数、赋值运算符重载以及浅拷贝和深...
c++ primer plus 第六版 课后习题答案
01-15
文件名为“8482739_C++ Primer Plus（第6版）中文版》习题答案.tar”的压缩包，包含了本书习题的详细解答，可能是以文本或PDF格式提供。这个资源对于自学C++或者正在学习C++ Primer Plus第六版的读者来说，是非常...
C++ primer Plus（第六版）第十二章 类和动态内存分配 章节编程练习答案
是鲤鱼啊
01-30 443
1.对于下面的声明： class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char * nm, const char * ho, double wt); Cow(const Cow c&); ~Cow(); Cow & operator=(const Cow & c); void ShowCow() co...
《C++ primer》--第12章
weixin_34195364的博客
08-08 83
习题12.7 什么是封装？为什么封装是有用的？ 解答： 封装是一种将低层次的元素组合起来形成新的、高层次实体的技术。例如，函数是封装的一种形式：函数所执行的细节行为被封装在函数本身这个更大的实体中；类也是一个封装的实体：它代表若干成员的聚集，大多数（良好设计的）类类型隐藏了实现该类型的成员。 封装隐藏了内部元素的实现细节（例如，可以调用一个函数但不能访问它所执行的语句），其主要优点在于：避免...
c/c++理论基础知识选择填空题库2
一只可爱的小猴子的博客
09-02 3490
在一个C源程序文件中,若要定义一个只允许本源文件中所有函数使用的全局变量,则该变量需要使用的存储类别是 【正确答案: D】。 (A) extern (B) register © auto (D) static C++语言程序由函数组成。它的 【正确答案: B】。 (A)主函数必须在其他函数之前，函数内可以嵌套定义函数 (B)主函数可以在其他函数之后，函数内不可以嵌套定义函数 ©主函数必须在其他函数之前，函数内不可以嵌套定义函数 (D)主函数必须在其他函数之后，函数内可以嵌套定义函 以下正
C ++ Primer Plus 第六版 第十二章编程练习答案
Fire_Sky_Ho的博客
08-11 1899
1.对于下面的类声明 class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char*nm, const char * ho, double wt); Cow(const Cow &c); ~Cow(); Cow & operator=(const Cow &c);
C++ Primer Plus（第六版）第六章编程练习答案
wyl1813240346的博客
10-24 3078
1.请编写一个程序，读取键盘输入，直到遇到@符号为止，并回显输入（数字除外），同时将大写字符转换为小写，将小写字符转换为大写（别忘了cctype函数系列） #include&amp;amp;amp;amp;lt;iostream&amp;amp;amp;amp;gt; #include&amp;amp;amp;amp;lt;cctype&amp;amp;amp;amp;gt; using namespace std; int main() { char ch;
C++ Primer Plus 第六版 所有章节课后编程练习答案
热门推荐
xiaojimmychen的专栏
11-01 8万+
C++ Primer Plus 第六版 所有章节课后编程练习答案
printf打印二进制数据
Norton的专栏
06-06 1万+
#include void decToBin(int num,int base); int main() { int decimalNum; int base=2; printf("Enter number in decimal:"); scanf("%d",&decimalNum); printf("\n"); printf("Decimal%d:",decimalNum);
C++ Primer Plus(6th edition) 第12章编程练习题
Ezra1991的博客
10-16 304
1.对于下面的类声明 class Cow { char name[20]; char * hobby; double weight; public: Cow(); Cow(const char*nm, const char * ho, double wt); Cow(const Cow &amp;c); ~Cow(); Cow &amp; operator=(const Cow &amp;c); ...
用c语言自己写一个简单的print函数
sanpam的博客
09-09 8282
#include &lt;stdio.h&gt; #define va_list void* #define va_arg(arg, type)    *(type*)arg; arg = (char*)arg + sizeof(type); #define va_start(arg, start) arg = (va_list)(((char*)&amp;(start)) + sizeof(...
数据结构C语言版（答案）
hrdzkj的专栏
09-15 6万+
第1章  绪论 1.1 简述下列术语：数据，数据元素、数据对象、数据结构、存储结构、数据类型和抽象数据类型。 解：数据是对客观事物的符号表示。在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称。     数据元素是数据的基本单位，在计算机程序中通常作为一个整体进行考虑和处理。     数据对象是性质相同的数据元素的集合，是数据的一个子集。     数据结构是相互之间存在
C++ Primer第四版课后习题答案1-18章
【资源摘要信息】: "这份资源是C++ Primer第四版的课后题解答，涵盖了从第一章到第十八章的全部内容，包括快速入门、变量和基本类型、标准库类型、数组和指针、表达式、语句、函数、标准IO库、容器、泛型算法、类和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值