C++ TGP 模板基础知识--02类模板、变量模板、别名模板

已于 2023-04-12 21:35:15 修改
阅读量543 收藏
点赞数
分类专栏： C/C++ 文章标签： c++ 开发语言
于 2023-03-24 17:09:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xxboy61/article/details/129754844
版权

类模板的基本范例和模板参数的推断

类模板是生产类的模具，通过给定的模板参数生成具体的类，也就是实例化一个特定的类，引入类模板的目的是减少代码冗余.类模板中只只有被调用的时候才会实例化该函数。

#include <iostream>
#include <string>
#include <vector>

template <typename T>  // T是类型模板参数
class MyVector {  // MyVector可以称为类名或者类模板，MyVector<T>可以称为类型名
  public:
    using myiterator = T*;

  public:
    MyVector();
    MyVector& operator=(const MyVector&);  // 赋值运算符重载

    void myfunc()
    {
        std::cout << "called myfunc" << std::endl;
    }

    static void myfuncs()
    {
        std::cout << "called myfuns" << std::endl;
    }

    myiterator mybegin();  // 迭代器的起始位置
    myiterator myend();  // 迭代器的结束位置
};

// 类模板实现
template <typename T>
MyVector<T>::MyVector()  // 类外构造函数的实现
{
    std::cout << "MyVector Constructed" << std::endl;
}

int main(int argc, char** argv)
{
    MyVector<int> vec;
    vec.myfunc();
    MyVector<std::string>::myfuncs(); 
    return 0;
}

模板参数推断

MyVector(T val)
{
    std::cout << "type t:" << typeid(val).name() << std::endl;
}

MyVector vec(10);// 无需指定模板参数
vec.myfunc();

模板参数推断指南

隐式推断指南

针对类模板的每个构造函数都有一个隐式的模板参数推断机制存在，称为隐式推断指南

// template<typename T>
// A(T, T) -> A<T>
// 表达式出现->左侧部分内容或者形式时，请推断成->右侧的类型。右侧类型也被称为“指南类型”
//->左侧部分：该推断指南所对应的构造函数的函数声明，多个参数之间用,分割
//->右侧部分：类模板名，接着一个尖括号，尖括号中时模板参数名
//整个推断指南的含义：当调用带2个参数的构造函数通过类模板A创建相关对象时，请用所提供的构造函数的实参来推断类模板A的模板参数类型

#include <iostream>
#include <string>
#include <vector>

template <typename T>
class A {
  public:
    A(T val1)
    {
        std::cout << "A(T val1) construct called"
                  << " type t:" << typeid(val1).name() << std::endl;
    }

    A(T val1, T val2)
    {
        std::cout << "A(T val1, T val2) construct called"
                  << " type t:" << typeid(val1).name() << std::endl;
    }
};

int main(int argc, char** argv)
{
    A obj1(12, 15);  // A<int>
    A obj2(12.2);  // A<double>
    return 0;
}

类模板的各种特化

一般来讲所写的类模板都是泛化的类模板。而特化的类模板是通过泛化的类模板生成的，因此先要有泛化版本，才有特化版本

类模板的全特化

全特化就是把A泛化版本中的所有模板参数都用具体的类型来代替构成的一个特殊的版本（全特化版本）

#include <iostream>
#include <string>
#include <vector>

template <typename T, typename U>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

// 全特化
template <>  // 所有类型模板参数都由具体的类型代表，所以<>里空了
class A<int, int> {
  public:
    A()
    {
        std::cout << "A 全特化版本构造函数执行了" << std::endl;
    }
    // 类中实现
    void func()
    {
        std::cout << "A 全特化版本func()执行了" << std::endl;
    }
    void func2()
};

// 类外实现
void A<int, int>::func2()
{
    std::cout << "A 全特化版本func2()执行了" << std::endl;
}

int main(int argc, char** argv)
{
    // 泛化
    A<int, float> obj1;
    obj1.func();
    // 全特化
    A<int, int> obj2;
    obj2.func();
    obj2.func2();
    return 0;
}
普通成员函数的全特化
#include <iostream>
#include <string>
#include <vector>

template <typename T, typename U>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

// 类A成员函数void func()的全特化
template <>
void A<int, float>::func()
{
    std::cout << "A普通成员函数void func()的全特化版本 A<int, float>::func() 执行了" << std::endl;
}

int main(int argc, char** argv)
{
    A<int, float> obj1;
    obj1.func();
    return 0;
}
静态成员变量的全特化
#include <iostream>
#include <string>
#include <vector>

template <typename T, typename U>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }

    static int m_val;  // 声明一个静态成员变量
};
// 静态成员变量定义
template <typename T, typename U>
int A<T, U>::m_val = 50;

// 静态成员变量的全特化
template <>
int A<double, int>::m_val = 100;

int main(int argc, char** argv)
{
    A<int, double> obj1;
    std::cout << "m_val:" << obj1.m_val << std::endl;

    A<double, int> obj2;
    std::cout << "m_val:" << obj2.m_val << std::endl;

    return 0;
}

注意：如果进行了普通成员函数的全特化或者是静态成员变量的全特化，那么就无法使用这些全特化指定类型来对整个类模板进行全特化了。下例失败

// ERROR 类模板全特化
template<>
class A<double, int>
{
    A()
    {
        std::cout << "A 全特化版本构造函数执行了" << std::endl;
    }
}
类模板的偏特化（局部特化）
模板参数数量上的偏特化
#include <iostream>
#include <string>
#include <vector>

template <typename T, typename U>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

// 偏特化
template <typename U>
class A<double, U> {
  public:
    A()
    {
        std::cout << "A<double, U> 偏特化版本构造函数执行了" << std::endl;
    }
    void func();
};

template <typename U>
void A<double, U>::func()
{
    std::cout << "A<double, U> 偏特化版本func() 执行了" << std::endl;
}

int main(int argc, char** argv)
{
    // 泛化
    A<int, double> obj1;
    obj1.func();
    // 偏特化
    A<double, int> obj2;
    obj2.func();
    return 0;
}
模板参数范围上的偏特化

int -> const int, T -> T*, T -> T&, T -> T&&

#include <iostream>
#include <string>
#include <vector>

template <typename T, typename U>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

// 范围偏特化
template <typename T, typename U>
class A<const T, U*> {
  public:
    A()
    {
        std::cout << "A<const T, U*> 偏特化版本构造函数执行了" << std::endl;
    }
    void func();
};

template <typename T, typename U>
void A<const T, U*>::func()
{
    std::cout << "A<const T, U*> 偏特化版本func() 执行了" << std::endl;
}

int main(int argc, char** argv)
{
    // 泛化
    A<int, double> obj1;
    obj1.func();
    // 偏特化
    A<const double, int*> obj2;
    obj2.func();
    return 0;
}

缺省参数

常规缺省参数

类型模板参数缺省值的规则：如果某个模板参数有缺省值，那么从这个缺省值的模板参数开始， 后面的所有模板参数都得有缺省值。类模板偏特化版本中的类型模板参数不能有缺省值

#include <iostream>
#include <string>
#include <vector>
// template <typename T, typename U>
template <typename T = int, typename U = int>  // 指定缺省类型
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }

    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

int main(int argc, char** argv)
{
    A obj1;
    obj1.func();

    A<>       obj2;  // 使用了缺省模板参数，所以<>中啥也不提供
    A<double> obj3;  //<>中第一个类型参数不使用缺省参数，第二个类型使用缺省参数
    return 0;
}
后面的模板参数依赖前面的模板参数
#include <iostream>
#include <string>
#include <vector>
template <typename T, typename U = T*>  // 后面的模板参数U依赖前面的模板参数T
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }

    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

int main(int argc, char** argv)
{
    A<double> obj1;
    obj1.func();

    return 0;
}
在模板声明中指定缺省参数
#include <iostream>
#include <string>
#include <vector>

// 声明1 指定V,W的缺省参数
template <typename T, typename U, typename V = int, typename W = char>
class A;

// 声明2 指定U缺省值，相当于U、V、W都指定了缺省参数
template <typename T, typename U = char, typename V, typename W>
class A;

// 定义泛化版本
template <typename T, typename U, typename V, typename W>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }

    void func()
    {
        std::cout << "A 泛化版本func() 执行了" << std::endl;
    }
};

int main(int argc, char** argv)
{
    A<double> obj1;  // 第2、3、4个模板参数采用缺省值，所以<>里只提供了一个类型模板实参
    obj1.func();

    return 0;
}
类型别名
  • typedef
    • typedef A<int, double> INT_D_A;
  • using
    • using INT_D_A = A<int, double>
非类型模板参数
#include <iostream>
#include <string>

// ArraySize
template <typename T, typename U, size_t ArraySize = 8>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了,array_size:" << ArraySize << std::endl;
    }
    void func();

  private:
    T m_arr[ArraySize];  // ArraySize在编译器编译期间确定
};
// 非类型模板参数，类的成员函数类外实现
template <typename T, typename U, size_t ArraySize>
void A<T, U, ArraySize>::func()
{
    std::cout << "A 泛化版本A<T, U>::func执行了" << std::endl;
}

int main(int argc, char** argv)
{
    A<double, int> obj1;  // 缺省的第三个模板参数是8
    obj1.func();

    A<double, int, 10> obj2;
    obj2.func();
    return 0;
}

成员函数模板

基本概念、构造函数模板
  • 类模板中的成员函数，只有源程序代码中出现调用这些成员函数代码时，这些成员函数才会出现在一个实例化了的类模板中
  • 类模板中的成员函数模板，只有源程序代码中出现调用这些成员函数模板的代码时，这些成员函数模板的具体实例才会出现在一个实例化了的类中
  • 目前编译器并不支持虚成员函数模板，因为虚函数表vtbl的大小是固定的。如果允许虚函数模板，则每次使用新的模板参数类型调用该虚函数模板时，就必须给对应的虚函数表在增加一项，这意味着只有在链接程序的时候才能去构造虚函数表，并在表中设置相关函数，因此成员函数模板绝不能为虚的
    • 类模板中可以有普通的虚成员函数（虚函数），因为普通成员函数如果不被调用时是不会被实例化的。但是对于虚函数，不管是否调用，编译器都会把它实例化出来。因为编译器要创建虚函数表vtbl，该表中的每个具体表项都对应一个虚函数地址
#include <iostream>
#include <string>

template <typename T1>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }

    template <typename T2>
    A(T2 v1, T2 v2);  // 构造函数模板，引入了自己的模板参数T2

    A(double v1, double v2)  // 构造函数
    {
        std::cout << " A(double, double)构造函数执行了" << std::endl;
    }

    A(T1 v1, T1 v2)
    {
        std::cout << " A(T1, T1)构造函数执行了" << std::endl;
    }

    template <typename T3>
    void func(T3 val)  // 普通成员函数模板
    {
        std::cout << "A func va;:" << val << std::endl;
    }

  private:
    T1                   m_val;
    static constexpr int m_static_val = 200;
};

// 类外实现类模板的构造函数模板
template <typename T1>  // 类模板
template <typename T2>  // 成员函数模板
A<T1>::A(T2 val1, T2 val2)
{
    std::cout << "A<T1>::A(T2, T2) 构造函数执行了, type T2:" << typeid(val2).name()
              << " type m_val:" << typeid(m_val).name() << std::endl;
}

int main(int argc, char** argv)
{
    A<float> obj1(1, 2);  // 实例化了A<float>这样一个类型，并用int类型来实例化构造函数
    A<float> obj2(1.2, 2.3);  // A<float>上面已经实例化了，并用double类型来实例化构造函数
    A<float> obj3(1.2f, 2.3f);  // 用float类型来实例化构造函数
    return 0;
}
拷贝构造函数模板与拷贝赋值运算符模板

拷贝构造函数模板不是拷贝构造函数，拷贝赋值运算符模板不是拷贝赋值运算符，构造函数模板也不是构造函数。拷贝构造函数或者拷贝赋值运算符要求拷贝的对象类型完全相同，而拷贝构造函数模板和拷贝赋值运算符模板就没有这种要求。拷贝构造函数模板永远不会成为拷贝构造函数。当**类型不同但 都是类模板实例化出来的两个对象时（如A和A）用一个拷贝构造另一个时，拷贝构造函数模板才会调用

#include <iostream>
#include <string>

template <typename T1>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    // 拷贝构造函数模板
    template <typename U>
    A(const A<U>& other)
    {
        std::cout << "A::A(const A<U>& other)构造函数执行了" << std::endl;
    }
    // 拷贝赋值运算符模板
    template <typename U>
    A<T1>& operator=(const A<U>& other)
    {
        std::cout << "A<T1> &operator=(const A<U> &other)构造函数执行了" << std::endl;
        return *this;
    }

    template <typename T3>
    void func(T3 val)  // 普通成员函数模板
    {
        std::cout << "A func va;:" << val << std::endl;
    }

  private:
    T1 m_val;
};

int main(int argc, char** argv)
{
    A<double> obj1;
    A<double> obj2(obj1);  // 未执行拷贝构造函数模板的代码,因为obj1、obj2类型相同，
                          // 本该执行拷贝构造函数，但是因为类模板中没有拷贝构造函数，所以编译器内部实际是执行了按值拷贝的一个操作
                          // 拷贝构造函数模板永远不会称为拷贝构造函数，编译器不会调用拷贝构造函数模板来代替拷贝构造函数
    A<int>   obj3(obj1); // obj1:A<double> obj3:A<int>，两者类型不同

    A<int>   obj4 = obj1;
    return 0;
}
特化
#include <iostream>
#include <string>

template <typename T1>
class A {
  public:
    A()
    {
        std::cout << "A 泛化版本构造函数执行了" << std::endl;
    }
    // 拷贝构造函数模板
    template <typename U>
    A(const A<U>& other)
    {
        std::cout << "A::A(const A<U>& other)构造函数执行了" << std::endl;
    }
    // 拷贝赋值运算符模板
    template <typename U>
    A<T1>& operator=(const A<U>& other)
    {
        std::cout << "A<T1> &operator=(const A<U> &other)构造函数执行了" << std::endl;
        return *this;
    }

    template <typename T3, typename T4>
    void func(T3 val1, T4 val2)  // 普通成员函数模板
    {
        std::cout << "A func(T3, T4) 泛化版本"
                  << "type val1:" << typeid(val1).name() << "type val2:" << typeid(val1).name() << std::endl;
    }
    // 成员函数 偏特化
    template <typename T4>
    void func(int val1, T4 val2)
    {
        std::cout << "A func(int, T4) 偏特化版本"
                  << "type val1:" << typeid(val1).name() << "type val2:" << typeid(val1).name() << std::endl;
    }
    // 成员函数全特化
    // template <>
    // void func(int val1, double val2)
    // {
    //     std::cout << "A func(int, double)全特化版本"
    //               << "type val1:" << typeid(val1).name() << "type val2:" << typeid(val1).name() << std::endl;
    // }

  private:
    T1 m_val;
};

int main(int argc, char** argv)
{
    A<double> obj1;

    return 0;
}

变量模板与成员变量模板

变量模板

// 变量模板泛化
template <typename T>
T g_var{};

// g_var<float> = 12.0;
// g_var<int> = 10;

变量模板的特化

// 变量模板全特化
template <>
char g_var<double>{};  // 变量模板特化时不需要正在特化的类型（double）与这个变量模板的类型（char）保持一致
 g_var<double> = 'a';

// 变量模板偏特化
template <typename T>
T g_var<T*>{120}; // T*依赖T

std::cout << g_var<int *> << std::endl;

默认模板参数

template <typename T = int>
T g_var;

非类型模板参数

// 非类型模板参数 value
template <typename T, int value>
T g_var[value];

for (int i = 0; i < 10; ++i) {
    g_var<int, 10>[i] = i;
}

for (int i = 0; i < 10; ++i) {
    std::cout << g_var<int, 10>[i] << std::endl;
}

变量模板的另一种形式

template <typename T>
struct B
{
    constexpr static T value = 160;
};

template <typename T>
int g_val = B<T>::value;

std::cout << g_val<int> << std::endl; // 160
g_val<int> = 120;
std::cout << g_val<int> << std::endl; // 120

成员变量模板

template <typename T>
class D {
  public:
    template <typename W>
    static W m_tpi;  // 静态成员变量模板声明
};

template <typename T>
template <typename W>
W D<T>::m_tpi = 5;

int main(int argc, char** argv)
{
    std::cout << D<float>::m_tpi<int> << std::endl;
    D<float>::m_tpi<int> = 150;
    std::cout << D<float>::m_tpi<int> << std::endl;

    return 0;
}

别名模板与成员别名模板

// 别名模板
template <typename T>
using str_map_t = std::map<std::string, T>;

template <typename T>
class E {
    // 成员别名模板
    template <typename T>
    using str_map_t = std::map<std::string, T>;

};
血_影
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++(14)：变量模板
风静如云的博客
06-21 552
C++14将模板的返回进一步扩大，可以声明变量模板：
极漂亮的PPT模板 658TGp_fruit_light_ani_red
03-30
极漂亮的PPT模板 658TGp_fruit_light_ani_red 下载你肯定不后悔。在同样类型的模板中间可以相互粘贴，色系会自动调整到一致状态，非常亮眼。
227TGp_report_light_v2 PPT模板
05-25
非常漂亮的PPT模板，在同样类型的模板中间可以相互粘贴，色系会自动调整到一致状态，非常亮眼。
TGP模拟登录账号-易语言
06-12
TGP模拟登录账号
商务PPT模板
02-13
商务PPT模板，有436TGp_biz_dark_ani沟通无极限.ppt、Business矢量商务素材.ppt等
跟我学c++中级篇——变量模板
fpcc的专栏
12-24 1909
对c++的变量模板进行分析说明，特别是一些常用的用法进行举例
C++模板元编程（19）变量模板用法与实战
二进制君
07-15 420
变量模板的定义方式与函数模板或类模板类似，只是它定义的是一个变量。在这个例子中，pi是一个变量模板，它可以用于任何类型T。当你使用pi时，你得到的是一个double类型的π值。同样，pi将给你一个int类型的π值（在这种情况下，它将被截断为3）。变量模板的一个常见用途是定义常量。这个变量模板可以用于任何类型T。当你使用Pi时，你得到的是一个double类型的π值。同样，Pi将给你一个int类型的π值（在这种情况下，它将被截断为3）。
C++14变量模板
a4364634611的博客
05-09 1782
如果对模板或者C++标准感兴趣的开发者们相信都不会对变量模板感到陌生，我们今天就讲一讲变量模板 从C++14 开始，变量也可以被某种类型参数化。称为变量模板。 例如可以通过下面的代码定义pi，但是参数化了其类型： template<typename T=int>//我们写作默认int T pi{};//初始化列表 为0 int main() { std::cout.precision(16); pi<int> = 20;//pi<>=20;效果一样 st.
【C++14保姆级教程】变量模板，Labmda泛型
m0_62599305的博客
10-11 186
C++14引入了一些强大的特性，使得程序员能够更加灵活和通用地编写代码。其中两个重要的特性是变量模板和Lambda泛型。本文将详细介绍这两个特性的概念、使用方法以及示例代码。变量模板和Lambda泛型是C++14引入的两个强大特性，可以使代码更通用和灵活。变量模板允许我们创建通用的变量定义，根据不同的参数值生成不同的变量；Lambda泛型允许我们编写可以接受任意类型参数的Lambda表达式。这两个特性在编写更通用、灵活且代码更简洁的代码时非常有用。
类模板、变量模板、别名模板 基础知识点二
weixin_42136255的博客
12-31 599
类模板、变量模板、别名模板 基础知识点二
TGP登录协议源码-易语言
06-12
TGP登录协议源码
C++模板详解
热门推荐
qq_52905520的博客
10-21 1万+
C++模板详解
C++标准 — C++14特性
coding-hwz
01-16 3894
C++标准 — C++14特性一、变量模板二、lambda 表达式的新增功能1、泛化2、对捕获的变量和引用进行初始化 一、变量模板 在C++11及之前，我们只有针对类和函数的模板。C++14中，新增了变量模板： template<class T> constexpr T pi = T(3.1415926535897932385L); template<class T> T circular_area(T r) { return pi<T> *r * r; } 变量模
C++基础::变量模板（variable template）
11-14 1万+
既然允许C++模板类（class template）的存在，允许C++函数模板（function template）的存在，也应当允许变量模板（variable template）的存在。 引入变量模板，标准C++14（C++11是C++14的一个subset子集，）的一个新的语法特性。C++新标准引入变量模板的主要目的是为了简化定义（simplify definitions）以及对模板化常量（pa
c++变量模板总结
qq_38158479的博客
10-31 1610
一：定义，泛化，全特化，偏特化，使用方法 #include <iostream> #include <boost/type_index.hpp> using namespace std; //变量模板的泛化版本 template <typename T> //(1) T g_tmp{};//变量的零初始化方式 //变量模板的全特化,,这里的char可以和int不一样 template<>//(2) char g_tmp<float>{'a'};
C++变量模板(variable template)
小孔明的专栏
06-07 1199
template用在一个变量上，其目的是什么呢？ https://blog.csdn.net/zwvista/article/details/54612025 #include <iostream> #include <iomanip> using namespace std; // 函数模板 template<class T> constexpr T pi_fn() { return T(3.1415926535897932385); } // 变量模板 templ
【C++】模板-非类型模板参数
weixin_56916549的博客
11-03 357
非类型模板参数 非类型的类模板参数 非类型的函数模板参数 非类型模板参数的限制 非类型模板参数总结 零初始化 模板不支持分离编译
C++泛型编程类模板，变量模板，别名模板，CSATD
这是一个c++热爱者的博客哟
12-31 898
15.1 模板概念与函数模板的定义、调用 15.1.1 模板概念 15.1.2 函数模板的定义 15.1.3 函数模板的调用 15.1.4 非类型模板参数 15.2 类模板概念与类模板的定义、使用 15.2.1 类模板概念 15.2.2 类模板的定义 15.2.3 类模板的成员函数 15.2.4 类模板名字的使用 15.2.5 非类型模板参数的使用 15.3 使用typename的场合、函数模板、默认模板参数与趣味写法 15.3.1 typename的使用场合 15.3.2 函数指针作为其他函数的参数 15
c++类模板
weixin_45827115的博客
05-06 66
模板主要是为了实现参数的多样化处理,不管传进来的参数是什么数据类型都可以按照固定算法运算 /--------------------------------------------------------------------/ 类模板声明: (下面类模板把参数1参数2存进一个数组里面) template class mypair { T values [2]; public: mypair (T first, T second) { values[0]=first; values[1]=second;
tgp clientkey
最新发布
12-13
TGP（全称为Tencent Games Platform）是腾讯公司推出的一款游戏开放平台，为开发者提供游戏开发、运营、发布以及社交互动等一站式解决方案。Clientkey是TGP平台为了保障游戏安全性和用户体验而设立的一个密钥。 TGP...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值