C++ 语言学习 day12 复习 （4）

最新推荐文章于 2024-10-04 20:50:17 发布
最新推荐文章于 2024-10-04 20:50:17 发布
阅读量214 收藏
点赞数
分类专栏： # C++  语言的学习 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/she666666/article/details/128043187
版权

1.模板

/**** 可以发现**************************************************
 * ①函数名相同,参数类型不同,模板函数可以与普通函数形成重载
 * ②当自己以及实现函数功能时,优先调用:已实现普通函数(原因CPU推到需要花时间)
 * ③调用有两种方式,自动类型推导 和 显示指定类型
 *      注意:我们经常用 显示指定类型(减少CPU推到时间)
 * ④模板的通用并不是万能的,在本案例中 数组就无法实现交换
 *      解决方案:自己实现普通函数高阶
 **************************************************************/

/********* 模板是动态绑定的: 也就是在调用时才产生 ******
 * 程序规则自上而下,从左往右:
 * 必须将模板放入同一文件
 * **********************************************/

代码：

#include <iostream>
using namespace std;
/**** 交换两个数据:定义myswap函数 ****/
void myswap(int &a,int &b) /*int 类型交换*/
{
    int temp = a;
    a = b;
    b = temp;
    cout << "void myswap(int &a,int &b)" << endl;
}

void myswap(char &a,char &b) /*char 类型交换*/
{
    char temp = a;
    a = b;
    b = temp;
    cout << "void myswap(char &a,char &b)" << endl;
}

/**** 使用模板技术 ****/
#include <typeinfo> /* 打印类型信息 */
template <class Type> /*建立 Type 虚拟万能类型 -> CPU自动推到 */
void myswap(Type &a,Type &b)
{
    Type temp = a;
    a = b;
    b = temp;

    cout << "\t类型名:" << typeid(Type).name()
         << "\t类型大小:" << sizeof(Type)
         << endl;
    cout << "void myswap(Type &a,Type &b)" << endl;
}



/**** 可以发现**************************************************
 * ①函数名相同,参数类型不同,模板函数可以与普通函数形成重载
 * ②当自己以及实现函数功能时,优先调用:已实现普通函数(原因CPU推到需要花时间)
 * ③调用有两种方式,自动类型推导 和 显示指定类型
 *      注意:我们经常用 显示指定类型(减少CPU推到时间)
 * ④模板的通用并不是万能的,在本案例中 数组就无法实现交换
 *      解决方案:自己实现普通函数高阶
 **************************************************************/
template <class Type> /*建立 Type 虚拟万能类型 -> CPU自动推到 */
void myswap(Type a[],Type b[])
{
    Type temp;
    for(int i = 0; i < 5;i++)
    {
        temp = a[i];
        a[i] = b[i];
        b[i] = temp;
    }
    cout << "void myswap(int a[],int b[])" << endl;
}

class People
{
public: /* 双目运算符 , <<高阶 , >> , [] , () */
    People(string name = "",int age = 0):m_name(name),m_age(age){} /*构造函数*/
    /* 编译器默认提供 =运算符重载(浅) */
    friend ostream &operator <<(ostream &out,const People &value)
    {
        out << "姓名:" << value.m_name << "\t年龄:" << value.m_age;
        return out;
    }

private:
    string m_name;
    int m_age;
};

int main()
{
    {/**** int 类型交换 *****/
        int a = 10,b = 20;
        myswap(a,b);    /* 自动类型推到 */
        cout << "a = " << a << "\tb = " << b << endl;
    }

    {/**** char 类型交换 *****/
        char a = 'A',b = 'B';
        myswap(a,b);    /* 自动类型推到 */
        cout << "a = " << a << "\tb = " << b << endl;
    }

    {/**** double 类型交换 *****/
        double a = 169.6,b = 157.4;
        myswap<double>(a,b); /* 指定显示类型调用 */
        cout << "a = " << a << "\tb = " << b << endl;
    }

    {/**** People 类型交换 *****/
        People a("师",18),b("老",19);
        myswap(a,b);
        cout << "a = " << a << "\tb = " << b << endl;
    }

    {/**** int 数组类型交换 *****/
        int addr_a[5] = {1,2,3,4,5};
        int addr_b[5] = {3,4,5,6,7};

        myswap(addr_a,addr_b);
        cout << "addr_a:";
        for(int i = 0; i < 5;i++)
        {
            cout << addr_a[i] << ",";
        }
        cout << endl;

        cout << "addr_b:";
        for(int i = 0; i < 5;i++)
        {
            cout << addr_b[i] << ",";
        }
        cout << endl;
    }

    return 0;
}

2.

/******* 类模板 *******
 * ①必须指定显示类型,在类名之后加<类型>
 * ②模板注意事项:
 *      1.程序自上而下,模板必须在同一文件
 *      2.类模板:尽量所有实现都写在同一文件
 * ******************/

代码：

list.h

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

/* 定义类模板: */
template <class Type>
class list
{
public:
    list():m_max(100),m_size(0)
    {
        m_addr = new Type[m_max];
    }

    ~list()
    {
        delete m_addr;
    }

public:
    Type &operator [](int index) /*[]运算符重载*/
    {
        return m_addr[index];
        /*000000000000...*/
    }

    void push_back(Type value)
    {
        if(m_size+1 >= m_max) /*空间不够,重新申请新空间*/
        {
            Type *addr = new Type[m_max*2];
            /**********拷贝老数据到新空间************/
            memcpy(addr,m_addr,sizeof(Type)*m_max);
            /**********释放老空间 ********/
            delete m_addr;
            /**********重新更改指向**********/
            m_addr = addr;
            /**********修改m_max******/
            m_max *= 2;
        }
        m_addr[m_size] = value;
        m_size++;
    }

    int size() const
    {
        return m_size;
    }

    void setSize(int size); /*类内.h声明,类.cpp实现*/

public: /* 单端动态数组 */
    Type *m_addr;/*类型 数组名[个数];*/
    int m_max;   /*数组长度*/
    int m_size;  /*当前有效元素个数*/
};



#endif // LIST_H

mian.cpp

#include <iostream>
#include "list.h" /*引入类模板*/

/****** 说过 #include 引入方式 *****
 * 自己工作路径 :   "头文件名"   -> 先工作路径 -> 系统目录 -> 结束
 * 系统库路径 :     <头文件名>   -> 直接系统目录 -> 结束
 * ******************************/

using namespace std;

/******* 类模板 *******
 * ①必须指定显示类型,在类名之后加<类型>
 * ②模板注意事项:
 *      1.程序自上而下,模板必须在同一文件
 *      2.类模板:尽量所有实现都写在同一文件
 * ******************/

int main()
{
    /**** 案例：int 类型 ****/
    list<int> v; /*不知道用户要使用的类型吧?*/
    /**** 使用自己的list *****/
    v.push_back(10);
    v.push_back(520);

    //v.setSize(0); /*报错:不同文件实现,晚绑定失败*/
    for(int i = 0; i < v.size();i++)
    {
        cout << v[i] << ",";
    }
    cout << endl;

    return 0;
}

3.模板类继承

代码：

#include <iostream>
using namespace std;

/**** 父类是类模板 ****/
template <class Type>
class A
{
public:
    Type m_value;
};

/**** B去继承于A类模板 ***/
class B : public A<int> /**指定显示继承**/
{
public:
    string m_name;
};

template <class Type>
class C : public A<Type>
{

};

int main()
{
    A<int> v;

    B b;
    b.m_name = "李四";

    C<string> c;
    c.m_value = "10.5";
    cout << c.m_value << endl;

    return 0;
}

4.STL 容器的使用 （vector）

/*********** vector 容器:单端数组 ************
 * 头文件:#include <vector>
 * 命名空间: using namemspace std
 *
 * 构造:vector()
 * 析构:~vector()
 * 尾插:push_back(Type Value)
 * 尾删:pop_back()
 * 清空:clear()
 * 访问:
 *      at(int index)
 *      [](int index)
 *      front()
 *      back()
 * 元素个数:size()
 * 注意:在C++库中,一般类名和文件名相同,库一般不带.h
 * *****************************************/
/*******************************************
 * 单端数据初体验:
 *  ①插入数据 -> ②遍历数据内容{[]和at and for_each算法} ->算法需要用到算法库 #include <algorithm>
 *    push_back      了解迭代器知识
 *
    /***************** 迭代器 *****************************************************
     * 通过基础知识,我们可以发现 vector是连续空间,所以迭代器是 随机访问迭代器
     * 作用:用于算法和容器之间的胶合剂
     * 定义迭代器变量:
     *      容器类型<类型>::iterator  迭代器变量名;
     * 使用迭代器:
     *      针对于容器类型,能支持访问的都有
     *          iterator begin() Vs iterator end() ,可以发现都返回的是迭代子类型
     *          begin() : 首迭代子 -> 存放的是第一个元素的位置
     *          end()   : 尾迭代子 -> 存放的是末尾之后的元素位置,所以没有数据,只是做标记
     *      访问数据规则:可以将迭代子理解为指针,指针访问数据可以有两种方法: * 和 ->
     *      随机访问迭代器规则: ++,--,[]
     *
     *      template<typename _IIter, typename _Funct>
     *      _Funct for_each(_IIter首迭代子, _IIter尾迭代子, _Funct仿函数策略)
     *                                                   _Funct 原型 void func(Type value);
     * **************************************************************************/

代码：

#include <iostream>

/* ①引入头文件和命名空间 */
#include <vector>
/* ②引入通用算法库 */
#include <algorithm>

using namespace std;
/*********** vector 容器:单端数组 ************
 * 头文件:#include <vector>
 * 命名空间: using namemspace std
 *
 * 构造:vector()
 * 析构:~vector()
 * 尾插:push_back(Type Value)
 * 尾删:pop_back()
 * 清空:clear()
 * 访问:
 *      at(int index)
 *      [](int index)
 *      front()
 *      back()
 * 元素个数:size()
 * 注意:在C++库中,一般类名和文件名相同,库一般不带.h
 * *****************************************/
/*******************************************
 * 单端数据初体验:
 *  ①插入数据 -> ②遍历数据内容{[]和at and for_each算法} ->算法需要用到算法库 #include <algorithm>
 *    push_back      了解迭代器知识
 * ****************************************/
void test0()
{
    /*1.创建 存放int类型的实例化对象*/
    vector<int> v;
    /*2.插入数据: 10 , 20 , 50 */
    v.push_back(10);
    v.push_back(20);
    v.push_back(50);
    /*3.访问容器*/
    cout << "当前元素个数:" << v.size() << endl;
    cout << "front = " << v.front() << endl;
    cout << "back = " << v.back() << endl;
#if 0
    for(int i = 0; i < v.size();i++)
    {
        //cout << v[i] << ",";  是vector容器的 []运算符重载
        cout << v.at(i) << ",";
    }
    cout << endl;
#else
    /*for_each()  遍历算法 */
    /***************** 迭代器 *****************************************************
     * 通过基础知识,我们可以发现 vector是连续空间,所以迭代器是 随机访问迭代器
     * 作用:用于算法和容器之间的胶合剂
     * 定义迭代器变量:
     *      容器类型<类型>::iterator  迭代器变量名;
     * 使用迭代器:
     *      针对于容器类型,能支持访问的都有
     *          iterator begin() Vs iterator end() ,可以发现都返回的是迭代子类型
     *          begin() : 首迭代子 -> 存放的是第一个元素的位置
     *          end()   : 尾迭代子 -> 存放的是末尾之后的元素位置,所以没有数据,只是做标记
     *      访问数据规则:可以将迭代子理解为指针,指针访问数据可以有两种方法: * 和 ->
     *      随机访问迭代器规则: ++,--,[]
     *
     *      template<typename _IIter, typename _Funct>
     *      _Funct for_each(_IIter首迭代子, _IIter尾迭代子, _Funct仿函数策略)
     *                                                   _Funct 原型 void func(Type value);
     * **************************************************************************/
     vector<int>::iterator it;

     cout << "*begin() = " << *v.begin() << endl;
     cout << "*end() = " << *v.end() << endl;
     cout << "*(--end()) = " << *(--v.end()) << endl;

     for(it = v.begin() ; it != v.end() ;it++)
     {
         cout << *it << ",";
     }
     cout << endl;

     class Print
     {
     public:
         void operator ()(int value)
         {
             cout << value << ",";
         }
     };

     for_each(v.begin(),v.end(),Print());
#endif
}

/********* 自己来实现以下 My_vector ************
 * 本质:数组(动态)
 * ******************************************/
template <class Type>
class My_vector
{
public: /*** 迭代器 ****/
    class iterator
    {
    public:
        iterator(Type *ptr = NULL):Ptr(ptr){}
        /*** 指针有访问操作: * 和 -> ***/
        Type &operator *()
        {
            return *Ptr;
        }

        iterator &operator ++()
        {
            Ptr++;
            return *this;
        }

        iterator operator ++(int)
        {
            iterator it(*this);

            Ptr++;

            return it;
        }
    private:
        Type *Ptr;
    };

public:
    My_vector() /*配置器*/
        :m_size(0),m_max(10)
    {
        /**** 申请空间 ****/
        m_ptr = new Type[m_max];
    }

    ~My_vector()
    {
        delete m_ptr;
    }

    void push_back(Type value)
    {
        if(m_size >= m_max)
        {
            /***** 申请空间 ******/
            Type *ptr = new Type[m_max*2];
            /***** 拷贝数据 ******/
            memcpy(ptr,m_ptr,sizeof(Type)*m_max);
            /***** 释放空间 ******/
            delete m_ptr;
            /***** 更改指向 ******/
            m_ptr = ptr;
            /***** 修改容量 ******/
            m_max = m_max * 2;
        }
        m_ptr[m_size] = value;
        m_size++;
    }

    Type &operator [](int index)
    {
        return m_ptr[index];
    }

    iterator begin()   /*第一个元素的位置*/
    {
        return iterator(m_ptr);
    }
protected:
    Type *m_ptr;    /*数组头*/
    int m_size;     /*元素个数*/
    int m_max;      /*容量*/
};

void test1()
{
    My_vector<int> v;

    v.push_back(10);
    v.push_back(20);

    cout << *v.begin() << endl;
    cout << *++v.begin() << endl;
}


/***** 存放自定义类型:Person ***************************
 * 成员: 姓名 + 年龄
 * 要注意数据结构中对自定义类型的支持:运算符重载实现
 * ****************************************************/
class Person
{
public:
    Person(string name = "",int age = 0):m_name(name),m_age(age){}
    string m_name;
    int m_age;
private:
    friend ostream &operator <<(ostream &out,Person person)
    {
        out << person.m_name << "\t"
            << person.m_age;
        return out;
    }
};

#include <vector>
#include <deque>    /*双端数组*/
#include <list>     /*链表*/
void test3()
{
    /**** 1.实例化STL对象 ****/
    vector<Person> v;
    /**** 2.插入数据 ******/
    v.push_back(Person("张三",17));
    v.push_back(Person("李四",18));
    /**** 3.输出数据 ******/
    //cout << v[0] << endl;
    //auto 自动类型推到   //iterator begin()
    for(auto it = v.begin() ; it != v.end() ;it++)
    {
        cout << *it << endl;
    }
}


/****** 人类分班 *********
 *
 *
 *
 * ********************/

void test4() /*容器嵌套*/
{
    /*实例化年级容器*/
    vector<vector<Person>> v;

    {/*一班*/
        vector<Person> v1;
        v1.push_back(Person("张三",18));
        v1.push_back(Person("李四",17));

//        vector<Person>::iterator it;
//        for(it = v1.begin();it != v1.end() ;it++)
//        {
//            cout << *it << endl;
//        }

        v.push_back(v1);
    }

    {/*二班*/
        vector<Person> v2;
        v2.push_back(Person("李白",650));

        v.push_back(v2);
    }


    /**** 遍历打印:年级 ****/
    vector<vector<Person>>::iterator it_i;    /*定义迭代子*/
    for(it_i = v.begin();it_i != v.end();it_i++)  /*迭代子  *it_i => vector<Person> */
    {
        vector<Person>::iterator it_j;
        cout << "班级信息:" << endl;
        for(it_j = (*it_i).begin() ; it_j != (*it_i).end() ;it_j++)/* 迭代子 *it_j => Person */
        {
            cout << *it_j << endl;
        }
    }
}





int main()
{
    //test0();
    //test1();
    test3();
    //test4();
    return 0;
}

_She001
关注
专栏目录
C++ 语言学习 day15 复习 （7）
she666666的博客
12-01 1088
liunx 连接百度云 ，人脸匹配，C++新特性，异常，lambda 函数（匿名函数）
C++ 语言学习 day10 复习（2）
she666666的博客
11-23 376
复习2
C++ 语言学习 day11 复习（3）
she666666的博客
11-24 427
复习： 继承，多态，虚析构，文件操作
C++ 语言学习 day13 复习 （5）
she666666的博客
11-29 298
容器 vector deque list string
C++ 语言学习 day14 复习 （6）
she666666的博客
12-01 318
stack queue pair键值对 set 集合 map 地图 ， linux 摄像头监控
【自用】C++学习-指针 Day 4
qq_45432533的博客
08-28 278
上面说到&是取地址符，&a是指获取变量a在内存中的地址，获得的是类似于上图中一串16进制的地址位。p作为指针，本身就是这一串16进制的地址，那么有什么办法可以知道p指向的内存的这个地址中存放的是什么数据呢。这就用到解地址符*。与int*的含义不同，这里的*充当的是解地址符的作用，*p就可以查看p这个门牌号下住的是什么数据。当定义一个指针后暂时不知道指向哪里时可以先置空，所谓置空就是让指针不指向任何一个地址，需要知道的是，当指针被置空后就不能给这个指针的解地址赋值，会引发错误。&a //取变量a的地址。
C++复习day10
2301_79420799的博客
09-11 1180
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一 块内存，用完后必须通过调用相应的 free或者delete 删掉。auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理。指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放 掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。通过下面的程序我们来测试shared_ptr的线程安全问题。
C++复习Day_4
weixin_55858644的博客
01-27 216
静态成员 静态成员 静态成员变量 所有对象都共享同一份数据 编译阶段就分配内存 类内声明、类外初始化 访问方式有两种：通过对象访问、通过类名访问 静态成员变量也是有访问权限 静态成员函数 所有对象都共享同一份函数 静态成员函数 只可以访问 静态成员变量，不可以访问非静态成员变量 静态成员函数 也是有访问权限的 静态成员函数 有两种访问方式：通过对象 、通过类名 单例模式 通过一个类 只能实例化唯一的一个对象 ...
C++复习day04
2301_79420799的博客
09-05 948
自然语言中，一个词可以有多重含义，人们可以通过上下文来判断该词真实的含义，即该词被重载了。比如：以前有一个笑话，国有两个体育项目大家根本不用看，也不用担心。一个是乒乓球，一个是男足。前者是“谁也赢不了！”，后者是“谁也赢不了！函数重载：是函数的一种特殊情况，C++允许在同一作用域中声明几个功能类似的同名函数，这些同名函数的形参列表(参数个数 或 类型 或 类型顺序)不同，常用来处理实现功能类似数据类型不同的问题。1. 参数类型不同2. 参数个数不同3. 参数顺序不同写个代码来举个例子。
day1-code.rar_达内_达内 c++_达内培训
09-24
综上所述，这个压缩包"day1-code.rar"对于想要学习或复习C++编程的人来说是一个宝贵的资源。它提供了达内教育的专业指导，可以帮助学习者逐步理解C++的基本概念、语法规则，并通过实践加深对编程的理解。无论是初学...
[学习笔记-C++篇]day10 标准库-实例
warningm_dm的博客
03-14 1142
c++复习训练
CSP考试复习：第一单元 C++语言基础 1.1 程序结构
zhengheda的博客
09-14 382
第一单元 C++语言基础 1.1 程序结构 (1) 程序框架  注释：注释有两种，一种是“//”，另一种是“/* … */”。“//”必须单独放置一行，或代码所在行 的后面；而“/*”、“*/”成对存在，可以插入到代码的任意位置。  引用头文件：在代码开头写“#include <头文件名>”。如果想引用自己的头文件，需要把尖括号（表 示只从系统目录搜索头文件）换成双引号（表示先从 cpp 所在文件夹搜索，然后再到系统文件夹搜索）。  命名空间：很多 C++的东西都要引用 s.
C++复习
wuyufei_sun的博客
06-04 393
C#是微软推出的一种面向对象的编程语言，专门用于.NET平台，结合了C++的功能和Java是简洁性，。用于开发Windows桌面应用、Web应用、游戏开发等。最初是为Windows开发的，随着.NET Core和.NET 5的推出，变得更加跨平台性。Java是一种面向对象的编程语言，具有跨平台性和安全性等特点。用于开发Web应用、移动应用、游戏等领域，是完全跨平台的语言，可以在任何支持Java虚拟机（JVM）的操作系统上运行。C++是一种面向对象的编程语言，是c语言的扩展。
深度学习每周学习总结J1（ResNet-50算法实战与解析 - 鸟类识别）
最新发布
qq_33489955的博客
10-04 765
数据导入及处理部分：本次数据导入没有使用torchvision自带的数据集，需要将原始数据进行处理包括数据导入，查看数据分类情况，定义transforms，进行数据类型转换等操作。划分数据集：划定训练集测试集后，再使用torch.utils.data中的DataLoader()分别加载上一步处理好的训练及测试数据，查看批处理维度.模型构建部分：resnet-50。
Go基础学习08-并发安全型类型-通道（chan）深入研究
FLJS_T的博客
09-28 897
在前面学习中了解到对于单值变量，如：int、string；多值变量，如：map存在多协程对资源竞争的并发问题，为了解决并发性通常需要引入sync.Mutex解决。>对于通道的基本声明方式有三种：声明并初始化带缓冲的通道（ch1）；声明并初始化一个不带缓冲的通道（ch2）；仅仅声明一个通道（ch3） >什么是通道：==一个通道相当于一个先进先出（FIFO）的队列。也就是说，通道中的各个元素值都是严格地按照发送的顺序排列的，先被发送通道的元素值一定会先被接收。Select和for循环实现对channel的多次选
10.2学习
2401_87363162的博客
10-02 1112
​ Spring AOP就是基于动态代理的，如果要代理的对象，实现了某个接⼝，那么Spring AOP会使⽤JDKProxy，去创建代理对象，⽽对于没有实现接⼝的对象，就⽆法使⽤ JDK Proxy 去进⾏代理了，这时候Spring AOP会使⽤基于asm框架字节流的Cglib动态代理 ，这时候Spring AOP会使⽤ Cglib ⽣成⼀个被代理对象的⼦类来作为代理。每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。
从0学习React（3）
qq_54432917的博客
09-29 717
在第一篇文章中，我们对index.tsx文件的每一行代码都做了简单的分析。通过第一篇文章的总结，我也大致知道了index.tsx里的很多语法。而第二篇文章，我对index.tsx文件的框架做了一个大致的分析，通过第二篇文章，我对index.tsx有了进一步的认识。按理来讲，第三篇文章我还是解析index.tsx文件，但是我发现，对于前两篇文章，其实我对语法的细节有很多不明白的点。因此这篇文章，我就把React的一些最基础的知识给梳理一下，帮助我更好的理解index.tsx的代码。
6.824 Lab 2C 学习记录
kingsill的博客
09-29 312
最后10s，开始的时候，恢复网络，插入一个数据，等待这个数据被提交，如果超过这10s就报错。2C的test中的unreliable figure8算是给博主的迎头一棒，需要根据raft论文的figure8进行解决，leader。根据前任及博主自己的经验，unreliable figure8的除了上述这一点以外，需要对。博主由于之前的不严谨，给自己留下了很大的改进困难，最后不得不重构代码。进行一定的设计，可以参考课程里老师提出的意见。一下为博主的github仓库，需要的可以参考。有一定的考验，那么就需要对。
C++编程基础与进阶复习指南
C++复习资料涵盖了语言基础、语法特性、内存管理、输入输出、异常处理以及关键数据类型等内容，对于准备计算机二级C++考试的学习者来说，是全面且深入的复习资源。通过理解和掌握这些内容，考生将能够熟练运用C++...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值