学习C++：C++基础（三）泛型编程&C++模板

已于 2022-06-21 22:06:46 修改
阅读量338 收藏 2
点赞数 1
分类专栏： C++ 基础 文章标签： 学习 c++ linq
于 2022-06-10 22:23:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41694024/article/details/125215686
版权

目录

1.0 模板概论

1.1 函数模板

1.1.1 模板声明及模板使用小案例

1.1.2 函数模板和普通函数的区别以及调用规则

1.1.3 函数机制和模板局限性

1.1.4 类模板

1.1.5 案例：myarray

1.0 模板概论

        C++提供了函数模板。所谓函数模板，实际上是建立了一个通用函数，其函数类型和形参类型不具体指定，用一个虚拟的类型来代表。这个通用函数就是函数模板。

        凡是函数体相同的函数都可以用这个模板代替，不必定义多个函数，只要在模板中定义一次即可。在调用函数时系统会根据实参的类型来取代模板中的虚拟类型，从而实现不同函数的功能。

1.1 函数模板

1.1.1 模板声明及模板使用小案例

1.实现任意两个数交换

void myswap(T& a,T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 1;
    int b = 2;
    float c = 1.1;
    float d = 2.2;
    myswap(a,b);
    myswap(c,d);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
a = 2
b = 1
c = 2.2
d = 1.1

2.模板声明

template<typename T>

这里的T是指代通用数据类型，告诉编译器如果下面的函数或者类中出现T不要报错。

3.模板使用

I.自动类型推导

自动判断a，b是int类型，必须推导出是一致的T数据类型，才能正确的使用模板。

II.显示指定类型

void test01()
{
    int a = 1;
    int b = 2;
    float c = 1.1;
    float d = 2.2;
    myswap<int>(a,b);
    myswap<float>(c,d);
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
    cout << "c = " << c << endl;
    cout << "d = " << d << endl;
}

III.模板不能单独使用，必须指定T才可以使用

4.案例：对char和int数组进行排序

void myswap(T& a,T& b)
{
    T temp = a;
    a = b;
    b = temp;
}


template<typename TE>
void mySort(TE arr[],int len)
{
    for(int i=0;i<len;i++)
    {
        int max = i;
        for(int j=i+1;j<len;j++)
        {
            if(arr[max]<arr[j])
            {
                max = j;
            }
        }
        if(i!=max)
        {
            myswap(arr[i],arr[max]);
        }
    }
}

template<typename T>
void printarray(T arr[],int len)
{
    for(int i=0;i<len;i++)
        cout << arr[i] ;
    cout << endl;
}

void test02()
{
    char chararray[] = "helloworld";
    int charlen = strlen(chararray);
    mySort(chararray,charlen);
    printarray(chararray,charlen);

    int intarray[] = {5,9,7,4,3,6,8};
    mySort(intarray,7);
    printarray(intarray,7);
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
wroolllhed
9876543

1.1.2 函数模板和普通函数的区别以及调用规则

1. 函数模板和普通函数的区别

void test03()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    //myadd1(a,c);  error 如果使用自动类型推导，是不允许发生隐式类型转换的
    cout << myadd2(a,c) << endl;    //普通函数允许发生隐式类型转换
}

函数模板如果使用自动类型推导，是不允许发生隐式类型转换的。

普通函数允许发生隐式类型转换

2. 函数模板和普通函数的调用规则

I.如果函数模板和普通函数都可以调用，那么优先调用普通函数。

template<typename T>
void printmt(T a,T b)
{
    cout << "template function is running" << endl;
}

void printmt(int a,int b)
{
    cout << "original function is running" << endl;
}

void test04()
{
    
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
original function is running

II.如果想强制调用函数模板，可以使用空模板参数列表

template<typename T>
void printmt(T a,T b)
{
    cout << "template function is running" << endl;
}

void printmt(int a,int b)
{
    cout << "original function is running" << endl;
}

void test04()
{
    printmt<>(10,20);
}

III.函数模板也可以发生函数重载

template<typename T>
void printmt(T a,T b)
{
    cout << "template function 2 is running" << endl;
}

template<typename T>
void printmt(T a,T b,T c)
{
    cout << "template function 3 is running" << endl;
}

void printmt(int a,int b)
{
    cout << "original function is running" << endl;
}

void test04()
{
    printmt<>(10,20,30);
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
template function 3 is running

IV.如果函数模板能产生更好的转换，优先选择函数模板

template<typename T>
void printmt(T a,T b)
{
    cout << "template function 2 is running" << endl;
}

template<typename T>
void printmt(T a,T b,T c)
{
    cout << "template function 3 is running" << endl;
}

void printmt(int a,int b)
{
    cout << "original function is running" << endl;
}

void test04()
{
    printmt<>('a','b');
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
template function 2 is running

1.1.3 函数机制和模板局限性

1.局限性

I.编译器并不是把函数模板处理成能够处理任何类型的数据---通过具体化解决

代码：看两个变量是否相等

class Person
{
public:
    Person(string name,int age)
    {
        this->name = name;
        this->age = age;
    }
    string name;
    int age;
};


template<class T>
bool mycompare(T& a,T& b)
{
    if(a==b)
        return true;
}

template<> bool mycompare(Person& a,Person& b)
{
    if(a.name==b.name && a.age==b.age)
        return true;
    else
        return false;
}

void test05()
{
    int a = 10;
    int b = 10;
    Person p1("Tom",19);
    Person p2("Tom",19);
    bool ret = mycompare(a,b);
    if(ret)
    {
        cout << "a = b" << endl;
    }
    else
    {
        cout << "a !=b ";
    }
}

II.函数模板通过具体类型产生不同的函数

template<class T>
bool mycompare(T& a,T& b)
{
    if(a==b)
        return true;
}

template<> bool mycompare(Person& a,Person& b)
{
    if(a.name==b.name && a.age==b.age)
        return true;
    else
        return false;
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
a = b

III.编译器会对函数模板进行再次编译，在声明的地方对模板代码本身进行编译，在调用的地方对参数替换后的代码进行编译。

1.1.4 类模板

1.声明

template<class NAMETYPE,class AGETYPE>
class Person
{
public:
    Person(NAMETYPE name,AGETYPE age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        cout << "name is : " << this->name << endl;
        cout << "age is : " << this->age << endl;
    }
    NAMETYPE name;
    AGETYPE age;
};

我们可以有多种模板声明，函数模板也可以。

2.调用

I.自动类型推导:类模板不可以用(对比于函数模板)

    Person p1("sunwukong",100);

这是错误的，在函数模板可以用在类模板不可以用。

II.指定类型

void test01()
{
    Person <string,int>p1("sunwukong",100);
    p1.showperson();
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
name is : sunwukong
age is : 100

3.类模板中成员函数创建时机

class Person1
{
public:
    void showperson1()
    {
        cout << "personshow1 is running" << endl;
    }
};

class Person2
{
public:
    void showperson2()
    {
        cout << "personshow2 is running" << endl;
    }
};

template<class T>
class Myclass
{
public:
    void Func1()
    {
        obj.showperson1();
    }
    void Func2()
    {
        obj.showperson2();
    }
    T obj;
};


void test01()
{
    Myclass<Person1> p1;
    p1.Func1();
    //p1.Func2();
    Myclass<Person2> p2;
    //p2.Func1();
    p2.Func2();
}

我们可以看到，p1调用不了Func2，p2调用不了Func1。

类模板中成员函数并不是一开始创建的，创建时机是在运行阶段确定出T的类型才创建的。

4.类模板做函数参数

I.指定传入类型

template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age)
    {
        this->name = name;
        this->age = age;
    }
    void showperson()
    {
        cout << "name is : " << this->name << endl;
        cout << "age is : " << this->age << endl;
    }
    T1 name;
    T2 age;
};

void dowork(Person<string,int>&p)
{
    p.showperson();
}

void test01()
{
    Person<string,int>p("sunwukong",99);
    dowork(p);
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
name is : sunwukong
age is : 99

不用编译器猜，自己提供数据类型

II.参数模板化

template<class T1,class T2>
void dowork(Person<T1,T2>&p)
{
    p.showperson();
}


void test02()
{
    Person<string,int>p("zhubajie",98);
    dowork(p);
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
name is : zhubajie
age is : 98

让编译器猜两个数据类型是什么

III.将整个类模板化

template<class T>
void dowork3(T& p)
{
    p.showperson();
}

void test03()
{
    Person<string,int>p("tangseng",10000);
    dowork3(p);
}
/home/lhw/桌面/C++/day8/cmake-build-debug/day8
name is : tangseng
age is : 10000

让编译器猜是哪个类

5.类模板遇到继承及解决

I.必须要指定出父类中T的类型，才能给子类分配内存

template<class T>
class Base
{
public:
    T m_a;
};

class son : public Base<int>
{

};

II.更灵活的方式

template<class T>
class Base
{
public:
    T m_a;
};

template<class T1,class T2>
class son : public Base<T2>
{
public:
    T1 m_b;
};

void test04()
{
    son <int ,double> s;
}
//m_a double m_b int

6.类模板的成员函数类外实现

template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age);
    void showperson();
    T1 name;
    T2 age;
};

template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->name = name;
    this->age = age;
}

template<class T1,class T2>
void Person<T1,T2>:: showperson()
{
    cout << "name is : " << this->name << endl;
    cout << "age is : " << this->age << endl;
}

7.类模板的分文件编写问题及解决

I.头文件.hpp

//
// Created by lhw on 2022/6/10.
//

#ifndef DAY8_PERSON_H
#define DAY8_PERSON_H

#include <iostream>
using namespace std;
template<class T1,class T2>
class Person
{
public:
    Person(T1 name,T2 age);
    void showperson();
    T1 name;
    T2 age;
};

template<class T1,class T2>
Person<T1,T2>::Person(T1 name,T2 age)
{
    this->name = name;
    this->age = age;
}

template<class T1,class T2>
void Person<T1,T2>:: showperson()
{
    cout << "name is : " << this->name << endl;
    cout << "age is : " << this->age << endl;
}

#endif //DAY8_PERSON_H

II.源文件 main.cpp

#include <cstring>
#include "person.hpp"

void dowork(Person<string,int>&p)
{
    p.showperson();
}

void test01()
{
    Person<string,int>p("sunwukong",99);
    dowork(p);
}


int main() {
    test01();
    return 0;
}

8.类模板碰到友元函数及其解决

I.友元函数类内实现

template<class T1,class T2>
class Person
{
public:
    friend void printperson(Person<T1,T2>&p)
    {
        cout << "name is : " << p.name << "age is : " << p.age;
    }

public:
    Person(T1 name,T2 age)
    {
        this->name = name;
        this->age = age;
    }

private:
    T1 name;
    T2 age;
};


void test03()
{
    Person<string,int>p("tom",100);
    printperson(p);
}

int main() {
    test03();
    return 0;
}

可以当作全局函数去调用。

II.友元函数类外实现1:有点复杂

template<class T1,class T2>
class Person;

template<class T1,class T2>
void printperson(Person<T1,T2>&p);

template<class T1,class T2>
class Person
{
public:
    friend void printperson<>(Person<T1,T2>&p);

public:
    Person(T1 name,T2 age)
    {
        this->name = name;
        this->age = age;
    }

private:
    T1 name;
    T2 age;
};

template<class T1,class T2>
void printperson(Person<T1,T2>&p)
{
    cout << "name is : " << p.name << "age is : " << p.age;
}

void test03()
{
    Person<string,int>p("tom",100);
    printperson(p);
}

III.友元函数类外实现2

template<class T1,class T2>
class Person;

template<class T1,class T2>
void printperson2(Person<T1,T2>&p)
{
    cout << "name is : " << p.name << "age is : " << p.age;
}

template<class T1,class T2>
class Person
{
public:
    friend void printperson2<>(Person<T1,T2>&p);
public:
    Person(T1 name,T2 age)
    {
        this->name = name;
        this->age = age;
    }

private:
    T1 name;
    T2 age;
};

void test03()
{
    Person<string,int>p("tom",100);
    printperson2(p);
}

1.1.5 案例：myarray

1.myarray.hpp

//
// Created by lhw on 2022/6/10.
//

#ifndef DAY8_MYARRAY_HPP
#define DAY8_MYARRAY_HPP

template<class T>
class Myarray
{
public:
    Myarray()
    {

    }
    Myarray(int capacity)
    {
        this -> capacity = capacity;
        this -> size = 0;
        this -> pAddress = new T[this->capacity];
    }
    Myarray(const Myarray & myarray)
    {
        this -> capacity = myarray.capacity;
        this -> size = myarray.size;
        this -> pAddress = new T[this->capacity];
        for (int i = 0 ; i<myarray.size ; i++)
        {
            this -> pAddress[i] = myarray.pAddress[i];
        }
    }
    Myarray& operator=(const Myarray & myarray)
    {
        if(this->pAddress)
        {
            delete []this->pAddress;
            this -> pAddress = NULL;
        }
        this -> capacity = myarray.capacity;
        this -> size = myarray.size;
        this -> pAddress = new T[this->capacity];
        for (int i = 0 ; i<myarray.size ; i++)
        {
            this -> pAddress[i] = myarray.pAddress[i];
        }
        return *this;
    }
    ~Myarray()
    {
        if(this->pAddress)
        {
            delete []this->pAddress;
            this -> pAddress = NULL;
        }
    }
    T& operator[](int index)
    {
        return this->pAddress[index];
    }
    void pushback(const T & value)
    {
        if(this -> capacity == this -> size)
        {
            return;
        }
        this -> pAddress[this->size] = value;
        this ->size ++;
    }
    int getCapacity()
    {
        return this->capacity;
    }
    int getSize()
    {
        return this->size;
    }

private:
    T * pAddress;
    int capacity;
    int size;
};

#endif //DAY8_MYARRAY_HPP

2.main.cpp

#include <iostream>
#include <cstring>

using namespace std;
#include "myarray.hpp"

class Person
{
public:
    Person(){};
    Person(string name,int age)
    {
        this -> name = name;
        this -> age = age;
    }

public:
    string name;
    int age;
};

void myprintint(Myarray<int> & myarray)
{
    for(int i=0;i<myarray.getSize();i++)
    {
        cout << myarray[i] << " ";
    }

}

void test01()
{
    Myarray<int> myintarray(100);
    for(int i = 0;i<10;i++)
    {
        myintarray.pushback(i+100);
    }
    myprintint(myintarray);
}

void myprintPerson(Myarray<Person> & perArr)
{
    for(int i =0 ; i<perArr.getSize() ; i++)
    {
        cout << "name is : " << perArr[i].name << endl << "age is : " << perArr[i].age << endl;

    }
}

void test02()
{
    Myarray<Person> myPersonarray(100);
    Person p1("sunwukong",10);
    Person p2("zhubajie",20);
    Person p3("tangseng",30);
    myPersonarray.pushback(p1);
    myPersonarray.pushback(p2);
    myPersonarray.pushback(p3);
    myprintPerson(myPersonarray);
    cout << "capacity is " << myPersonarray.getCapacity() << endl;
    cout << "size is " << myPersonarray.getSize() << endl;
}
int main() {
    test01();
    test02();
    return 0;
}

3.结果

/home/lhw/桌面/C++/day8/cmake-build-debug/day8
100 101 102 103 104 105 106 107 108 109 name is : sunwukong
age is : 10
name is : zhubajie
age is : 20
name is : tangseng
age is : 30
capacity is 100
size is 3

APS2023
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++模板元编程（0）模板编程与泛型编程
二进制君
04-04 3783
什么是元编程 元编程 (metaprogramming) 通过操作 程序实体 (program entity)，在 编译时 (compile time) 计算出 运行时 (runtime) 需要的常数、类型、代码的方法。 一般的编程是通过直接编写 程序 (program)，通过编译器 编译 (compile)，产生目标代码，并用于 运行时 执行。与普通的编程不同，元编程则是借助语言提供的 模板 (template) 机制，通过编译器 推导 (deduce)，在 编译时 生成程序。元编程经过编译器推导得到的程
C++泛型编程
蹦跶跶
06-04 6273
C++泛型编程与STL总结1. 泛型编程1.1 模板1.2 函数模板1.2.1 语法1.2.2 使用函数模板方式1.2.3 普通函数和函数模板的区别1.2.4 普通函数与函数模板的调用规则1.2.5 模板的局限性1.3 类模板2. STL技术 1. 泛型编程 泛型编程最初诞生于C++中。目的是为了实现C++的STL（标准模板库）。其语言支持机制就是模板（Templates）。模板的精神其实很简单：参数化类型。换句话说，把一个原本特定于某个类型的算法或类当中的类型信息抽掉，抽出来做成模板参数T。（参考自Bai
C++——模板（泛型编程）
尖皇
01-16 728
学习黑马的实验，然后自己写类似的训练
C++提高编程——模板
qwer1234mnbv_的博客
06-25 447
模板属于C++的泛型编程，它通过建立通用模板，大大提高了代码复用性先声明模板的虚拟类型 后面紧跟着函数声明或定义，其参数类型用T替换如交换函数 可以看到，通过模板，交换函数能实现对不同数据类型的交换，使用时，可以直接传参赋值，编译器会自动推导类型，但两个数的类型必须相同，也可以指明数据类型。 模板参数类型声明可用typename,也可以用class，多个不同类型，可以声明多个虚拟参数来实现自动类型推导。 模板必须要确定数据类型才能使用 fun即使不传参，也要指明数据类型才能使用 其
C++模板笔记八：类模板分文件编写
xiaoyaolangwj的博客
01-29 2830
问题： 类模板中成员函数的创建时机：调用阶段。 导致份文件编写时链接不到。 解决： 解决方案１：直接包含.cpp源文件。把include "Person.h"变为 include “Person.cpp”。 解决方案2：将声明.h文件和实现.cpp文件写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。 示例： 头文件Person.h中代码： #pragma once #include<iostream> using namespace std; t
模板类实现数组
周杰伦
09-02 755
模板类实现数组 . #include&lt;iostream&gt; using namespace std; //数组：是一块连续空间 template&lt;typename T&gt; class Array { public: //声明构造器 Array(); Array(T*,int); T at(int );//返回指定位置的元素 unsigned short ...
模板template--typename T ,int N
wo.a的博客
04-25 2706
1.h #ifndef _1_H_ #define _1_H_ template &lt;typename T,int N&gt; class ARRAY { int length; T array[N]; public: ARRAY(); bool setvalue(int index,T value); bool getvalue(int index,T&amp; valu...
C++程序设计与实践：11-模板和泛型编程.ppt
06-12
C++程序设计与实践：模板和泛型编程 C++ 程序设计与实践中，模板和泛型编程是非常重要的概念。模板是 C++ 的泛型机制，用来实现泛型编程。泛型编程是指不依赖于任何具体类型来编写通用代码，具体类型信息的提供是在...
C++设计新思维：泛型编程与设计模式之应用(PDF)
10-18
通过阅读，不仅可以提升对C++泛型编程的理解，还能学习到如何将设计模式融入C++编程，从而提高自己的编程能力和软件设计水平。无论是初学者还是有经验的C++开发者，都能从中受益匪浅。因此，如果你对C++编程有着浓厚...
c++系列-泛型编程与模板-源码
最新发布
05-24
在C++编程语言中，泛型编程和模板是两个核心概念，它们极大地提升了代码的复用性和灵活性。本文将深入探讨这两个主题，并结合源码分析，帮助你更好地理解和应用它们。 ## 泛型编程 泛型编程是C++中一种抽象编程的...
C++ 模板详解（一）
weixin_33699914的博客
10-25 1466
C++模板 　　模板是C++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。 　　模板是一种对类型进行参数化的工具； 　　通常有两种形式：函数模板和类模板； 　　函数模板针对仅参数类型不同的函数； 　　类模板针对仅数据成员和成员函数类型不同的类。 　　使用模板的目的就是能够让程序员编写与类型无关的代码。...
template＜typename T＞简单用法
热门推荐
realjc的博客
09-09 2万+
template<typename T>的作用是使函数适用于不同的输入类型。 template<typename T> void print_num(const T num){ cout.setf(ios::showpoint); cout<<num<<endl; } int main () { int num1 = 1; print_num(num1); double num2 = 1.0; print
C++笔记 第六十五课 C++中的异常处理（下）---狄泰学院
YLC_慕类的博客
11-30 223
如果在阅读过程中发现有错误，望评论指正，希望大家一起学习，一起进步。 学习C++编译环境：Linux 第六十五课 C++中的异常处理（下） 1.C++中的异常处理 catch语句块中可以抛出异常 2.问题 为什么要在catch中重新抛出异常？ 3.C++中的异常处理 catch中捕获的异常可以被重新解释后抛出 工程开发中使用这样的方式统一异常类型 65-1 异常的重新解释 假设：当前的函数式第...
c++ STL vector 的简易实现
zjheyibitiangao的博客
07-31 1228
template &lt;class T&gt; class myVector { public: myVector():p(NULL),capacity(0),size(0)//默认构造函数 { } myVector(int size)//默认赋值为0的构造函数 { this-&gt;size=size; this-&gt...
C++中使用set容器自定义规则排序运行报错C3848：具有类型“const MyCompare”的表达式会丢失一些...
Liuxm
01-28 607
VS2019，用到set容器进行自定义规则排序编译时，生成代码时运行报错： C3848，具有类型“const MyCompare”的表达式会丢失一些 const-volatile 限定符以调用“bool MyCompare::operator ()(int,int)” 如图： 解决方式： 在排序规则代码加上“const”，运行成功。 ...
C++中的Compare（）函数用法
WBENTELY的博客
05-19 1万+
#include #include #include using std::cout; using std::endl; using std::cin; using std::string; int main(void){ string str1="hi,test,hello"; string str2="hi,test"; //字符串比较 if(
C++像Python一样简洁地打印数组
weixin_42273095的博客
01-31 1221
虽然C++在当今时代已经是一种反人类的设计，但也只能勉强用，这是一种类似Python打印数组的方法： #include <iostream> int main(){ int arr[] = {1, 2, 3, 4}; printf("%s%d\n", "length: ",sizeof(arr) / sizeof(arr[0])); for(auto& i : arr) { std::cout<< i << std::endl; } } ..
C++实战（五）函数、数组、指针
Pinospot的博客
08-26 135
案例描述：创建一个数组，利用冒泡排序的方法升序排列 在主函数里调用函数，函数如果与数组有关，在调用的括号里需要数组的首地址和长度 #include<iostream> using namespace std; //冒泡排序的函数 void bubbleSort(int * arr,int len)//口号内按照你调用的来写，地址要加*解引用 { for (int i = 0; i < len - 1; i++)//冒泡排序标准，无论是背下来还是理解，都要能写出来 { for
C++ 模板函数 001:简单的SumArray 002 简单的foreach 003 简单的Filter 006 这个模板并不难
BLUEsang的博客
03-29 2056
001:简单的SumArray 描述 填写模板 PrintArray,使得程序输出结果是： TomJackMaryJohn 10 不得编写SumArray函数 #include <iostream> #include <string> using namespace std; template <class T> T SumArray( // 在此处补充你的代码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

APS2023

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值