2.类模板

最新推荐文章于 2022-10-09 10:38:35 发布
最新推荐文章于 2022-10-09 10:38:35 发布
阅读量350 收藏
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Bigfish_k/article/details/105948398
版权

Primer总目录

目录

  • 模板定义

    template<typename T> or template<class T>

  • 区别函数模板

    1、类模板没有自动类型推导使用方式
    2、类模板在模板参数列表中可以有默认参数

template<class NameType,class AgeType = int>
class Person{
public:
	Person(NameType name, AgeType age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}
	void showPerson()
	{
		cout << "name: " << this->m_Name << " age = " << this->m_Age << endl;	
	}
	NameType m_Name;
	AgeType m_Age;
};
int main(){
	//Person p("孙悟空", 1000); 错误，无法用自动类型推导
	Person<string, int>p("孙悟空", 1000); //正确，只能用显示指定类型
	Person<string>p1("猪八戒", 999);//默认参数
	p.showPerson();
	p1.showPerson();
}

  3、类模板中成员函数只在调用时才会创建

//两个类
Class Person1{
	void showPerson1()
};
Class Person2{
	void showPerson2() 
};
//类模板
template<class T>
Class MyClass{
	T obj;
	void func1(){
		obj.showPerson1();
	}
	void func2(){
		obj.showPerson2();
	}
};
//测试
int main(){
	MyClass<Person2>m;
	m.func2();
}

回到顶部

  • 做函数参数
#include<iostream>
using namespace std;
#include <string>

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

	void showPerson()
	{
		cout << "姓名： " << this->m_Name << " 年龄： " << this->m_Age << endl;
	}

	T1 m_Name;
	T2 m_Age;
};

//1、指定传入类型（这个常用）
void printPerson1(Person<string, int>&p)
{
	p.showPerson();
}
void test01()
{
	Person<string, int>p("孙悟空", 100);
	printPerson1(p);
}

//2、参数模板化
template<class T1,class T2>
void printPerson2(Person<T1, T2>&p)
{
	p.showPerson();
	cout << "T1 的类型为： " << typeid(T1).name() << endl;
	cout << "T2 的类型为： " << typeid(T2).name() << endl;
}
void test02()
{
	Person<string, int>p("猪八戒", 90);
	printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3( T &p)
{
	p.showPerson();
	cout << "T的数据类型为： " << typeid(T).name() << endl;
}
void test03()
{
	Person<string, int>p("唐僧", 30);
	printPerson3(p);
}

int main() {
	//test01();
	//test02();
	test03();
	system("pause");
	return 0;
}

回到顶部

  • 类模板与继承
    1、当父类是模板时，子类声明需指定父类中T的类型
    2、不指定，编译器无法为子类分配内存
    3、若想灵活指出父类中T的类型，子类需变为类模板
template<class T>
class Base
{
	T m;
};
//子类声明时，指定父类T
class Son:public Base<int>
{
};
//如果想灵活指定父类中T类型，子类也需要变类模板
template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
	Son2()
	{
		cout << "T1的类型为： " << typeid(T1).name() << endl;
		cout << "T2的类型为： " << typeid(T2).name() << endl;
	}
	T1 obj;
};

void test02()
{
	Son2<int, char>S2;
}

回到顶部

  • 模板类与友元
    • 全局函数类内实现–直接在类内声明友元
    • 全局函数类外实现–需提前让编译器知道全局函数的存在
//通过全局函数 打印Person信息

//提前让编译器知道Person类存在
template<class T1, class T2>
class Person;

//类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> p)
{
	cout << "类外实现 --- 姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
}

template<class T1,class T2>
class Person
{
	//全局函数 类内实现
	friend void printPerson(Person<T1,T2> p)
	{
		cout << "姓名： " << p.m_Name << " 年龄： " << p.m_Age << endl;
	}

	//全局函数 类外实现
	//加空模板参数列表
	//如果全局函数 是类外实现，需要让编译器提前知道这个函数的存在
	friend void printPerson2<>(Person<T1, T2> p);

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

//1、全局函数在类内实现
void test01()
{
	Person<string, int>p("Tom", 20);
	printPerson(p);
}

//2、全局函数在类外实现
void test02()
{
	Person<string, int>p("Jerry", 20);
	printPerson2(p);
}

int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

回到顶部

  • 分文件编写

类模板成员函数在调用阶段创建，导致分文件编写链接不到

  1、直接包含.cpp文件

#include "Complex.cpp"
int main(){}

//函数实现放在类中
//Complex.cpp
#include<iostream>
using namespace std;
template <typename T>
class Complex
{	

   friend Complex Mysub(Complex &c1, Complex &c2)
   {
   	Complex temp(c1.a - c2.a, c1.b - c2.b);
   	return temp;
   }
   //friend ostream& operator<<(ostream &out, Complex &c3);//函数体外实现
   friend ostream& operator<<(ostream &out, Complex &c3)
   {
   	out << "a:" << c3.a << " b:" << c3.b << endl;
   	return out;

   }
public:
   Complex(T a, T b )
   {	
   	this->a = a;
   	this->b = b;
   }
   //重载运算符
   Complex operator+(Complex &c2)
   {
   	Complex temp(a + c2.a, b + c2.b);
   	return temp;
   }
   void printCom()
   {
   	cout << "a:" << a << "b" << b << endl;
   }
protected:
private:
   T a;
   T b;
};
//ostream& operator<<(ostream &out, Complex &c3)
//{
//	out << "a:" << c3.a << " b:" << c3.b << endl;
//	return out;
//}

  2、将声明和实现放在同一个文件中，并更改后缀名为.hpp

//complex.h
#include<iostream>
using namespace std;

template <typename T>
class Complex
{
	 //有元函数是全局函数,不属于这个类的
	friend Complex Mysub(Complex &c1, Complex &c2); 
 	 //不加<T>报错LINK2019,两次编译每次生成的函数头不一样
	friend ostream& operator<< <T>(ostream &out, Complex &c3); //重载<<

public:
		Complex(T a, T b);//构造
		void printCom();
		Complex operator+(Complex &c2);//重载+
		/*Complex operator-(Complex &c2);*/
private:
	T a;
	T b;
};

//complex.hpp

#include<iostream>
using namespace std;
#include "complex.h"
//构造函数写在类的外部..h和.cpp
template<typename T>
Complex<T>::Complex(T a, T b)
{
	this->a = a;
	this->b = b;
}
 template<typename T>
void Complex<T>::printCom() //函数的名前加类的域名,因为他是成员函数
{
	cout << "a:" << a << "b" << b << endl;
}
//成员函数,实现+运算符重载
template<typename T>
Complex<T> Complex<T>::operator+(Complex<T> &c2) //第一个是Complex<T>函数的返回值,参数也要具体化,名称也加域名;函数体内部要不要具体化无所谓
{
	Complex temp(a + c2.a, b + c2.b);
	return temp;
}
//友元函数实现<<重载
template<typename T>
ostream& operator<<(ostream &out, Complex<T>&c3) //全局函数,不属于类,不加域名
{
	out << "a:" << c3.a << " b:" << c3.b << endl;
	return out;

}
//友元函数实现-重载
template<typename T>
Complex<T> Mysub(Complex<T> &c1, Complex<T> &c2)  
{
	Complex temp(c1.a - c2.a, c1.b - c2.b);
	return temp;
}


//测试代码
//#include "complex.h"
//#include "complex.cpp"//这里一点要注意了,要不然找不到函数体,两次编译惹的祸,所有常将cpp命名为hpp.与.h文件合二为一
#include "complex.hpp"
int main()
{   //需要将模板类具体化后,才能定义对象,C++编译器要分配内存
	Complex<int> c1(1, 2);
	Complex<int> c2(3, 4);
	Complex<int> c3 = c1 + c2;
	cout << c3 << endl;
	//滥用友元
	Complex <int> c4=Mysub(c1,c2);
	cout << c4 << endl;
	
	cout<<"hello..."<<endl;
	system("pause");
	return 0;
}

回到顶部

  • 例子
//MyVector.h
#include<iostream>
using namespace std;
template<typename T>
class MyVector
{
	friend ostream & operator<< <T>(ostream &out, const MyVector &obj);
public:
	MyVector(int size = 0);
	MyVector(const MyVector &obj);//拷贝构造函数
	~MyVector();
public:
	T& operator[](int index);//中括号重载
	MyVector& operator=(const MyVector &obj);	
public:
	int getlen()
	{
		return m_len;
	}
protected:
private:
	T *m_space;
	int m_len;
};

//MyVector.cpp
#include<iostream>
using namespace std;
#include "MyVector.h"

template<typename T>
ostream & operator<<(ostream &out, const MyVector<T> &obj)
{	
	for (int i = 0; i < obj.m_len; i++)
	{
		out << obj.m_space[i]<<" ";
	}
	cout << endl;//换行
	return out;
}
//MyVector<int> myv1(10);构造函数
template<typename T>
MyVector<T>::MyVector(int size)
{
	m_space = new T[size];
	m_len = size;
}
//MyVector<int> myv2 = myv1;
template<typename T>
MyVector<T>::MyVector(const MyVector &obj)//拷贝构造函数根据myv1大小分配内存,cpy数据
{
	m_len = obj.m_len;
	m_space = obj.m_space;

	for (int i = 0; i < obj.m_len; i++)
	{
		m_space[i] = obj.m_space[i];
	}
}
template<typename T>
MyVector<T>::~MyVector()
{
	if (m_space != NULL)
	{
		delete[]m_space;
		m_space = NULL;//避免野指针
		m_len;
	}
}
template<typename T>
T& MyVector<T>::operator[](int index)//中括号重载
{
	return m_space[index];
}
//a3=a2=a1
template<typename T>
MyVector<T>& MyVector<T>::operator=(const MyVector<T> &obj)
{	
	//先把a2的旧的内存释放掉
	if (m_space != NULL)
	{
		delete[]m_space;
		m_space = NULL;//避免野指针
		m_len;
	}
	//根据a1分配内存
	m_len = obj.m_len;
	m_space = new T[m_len];
	//copy数据
	for (int i = 0; i < m_len;i++)
	{
		m_space[i] = obj.m_space[i];
	}
	return *this;//返回数组的引用,即a2;
}

//MyVector 测试代码
#include<iostream>
using namespace std;
#include "MyVector.cpp"
//#define _CRT_SECURE_NO_WARNINGS
class Teacher //1优化Teacher类,属性变成char *pname,构造函数里分配内存 2.析构函数释放pname指向的内存空间 3.避免浅拷贝,重载= ,重写拷贝函数 4,在teacher增加<<
{
public:  //在模板数组类,存int char,Teacher, Teacher*;
	Teacher()
	{
		age = 33;
		//strcpy(name, "");
		m_p = new char[1];
		strcpy(m_p, "");
	}
	
	Teacher(char *name, int age)
	{
		this->age = age;
		//strcpy(this->name, name);
		m_p = new char[strlen(name) + 1];
		strcpy(m_p, name);
	}
	Teacher(const Teacher &obj)
	{
		m_p = new char[strlen(obj.m_p) + 1];
		strcpy(m_p, obj.m_p);
		age = obj.age;
	}
	~Teacher()
	{
		if (m_p!=NULL)
		{
			delete[]m_p;
			m_p = NULL;
		}
	}
	void prinT()
	{
		//cout << name << "," << age << endl;
		cout << m_p << "," << age << endl;
	}
public:
	friend ostream & operator<<(ostream &out, Teacher &t);
	Teacher& operator=(const Teacher & obj)
	{
		if (m_p!=NULL)
		{
			delete[]m_p;
			m_p = NULL;
			age = 33;
		}
		m_p = new char[strlen(obj.m_p) + 1];
		age = obj.age;
		strcpy(m_p, obj.m_p);
		return *this;
	}
private:
	int age;
	//char name[32];
	char *m_p;    //深拷贝,和浅拷贝
};

ostream & operator<<(ostream &out, Teacher &t)
{
	out << t.m_p << "," << t.age << endl;
	return out;
}

void main()//存指针
{
	Teacher t1("Li", 30), t2("YU", 24), t3("Zhao", 21);
	MyVector<Teacher*>tArry(3);
	tArry[0] = &t1;  //t1丢进容器里面
	tArry[1] = &t2;
	tArry[2] = &t3;
	for (int i = 0; i < 3; i++)
	{
		Teacher *tmp = tArry[i];
		tmp->prinT();
	}
	//cout << tArry;//类对象没有实现左移,所以不能调用底层的<<重载
	system("pause");
}

void main7()
{
	MyVector<char> myv1(10);
	myv1[0] = 'a';
	myv1[1] = 'b';
	cout << myv1;
	system("pause");
}
int main6()
{	
	MyVector<int> myv1(10);
	for (int i = 0; i < myv1.getlen(); i++)
	{
		myv1[i] = i + 1;
		cout << myv1[i] << " ";
	}
	cout << endl;

	MyVector<int> myv2 = myv1;
	for (int i = 0; i < myv2.getlen(); i++)
	{
		cout << myv2[i] << " ";
	}
	cout << endl;
	cout << myv2 << endl;//重载操作符
	//operator<<(ostream &out,const MyVector &obj)
	cout << "hello..." << endl;
	system("pause");
	return 0;
}

//自己的通用的数组类
//MyArray.hpp
#pragma once 
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:

	//有参构造  参数 容量
	MyArray(int capacity)
	{
		//cout << "Myarray有参构造调用" << endl;
		this->m_Capacity = capacity;
		this->m_Size = 0;
		this->pAddress = new T[this->m_Capacity];
	}

	//拷贝构造
	MyArray(const MyArray& arr)
	{
		//cout << "Myarray拷贝构造调用" << endl;
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		//this->pAddress = arr.pAddress;//浅拷贝（编译器）导致堆区的数据重复释放


		//深拷贝（在堆区重新开辟一个空间）
		this->pAddress =  new T[arr.m_Capacity];

		//将arr中的数据都拷贝过来
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
	}

	//operator= 防止浅拷贝问题 （a=b=c,=返回引用实现连续赋值）  
	MyArray& operator=(const MyArray& arr)
	{
		//cout << "Myarray  的 operator=调用" << endl;
		//先判断原来堆区是否有数据，如果有先释放
		if (this->pAddress != NULL)
		{
			delete[] this->pAddress;
			this->pAddress = NULL;
			this->m_Capacity = 0;
			this->m_Size = 0;
		}

		//深拷贝
		this->m_Capacity = arr.m_Capacity;
		this->m_Size = arr.m_Size;
		this->pAddress =  new T[arr.m_Capacity];
		for (int i = 0; i < this->m_Size; i++)
		{
			this->pAddress[i] = arr.pAddress[i];
		}
		return *this;
	}


	//尾插法
	void Push_Back(const T & val)
	{
		//判断容量是否等于大小
		if (this->m_Capacity == this->m_Size)
		{
			return;
		}
		this->pAddress[this->m_Size] = val; //在数组末尾插入数据
		this->m_Size++; //更新数组大小
	}

	//尾删法
	void Pop_Back()
	{
		//让用户访问不到最后一个元素，即为尾删，逻辑删除
		if (this->m_Size == 0)
		{
			return;
		}
		this->m_Size--;
	}

	//通过下标方式访问数组中的元素  arr[0] = 100
	T& operator[](int index)
	{
		return this->pAddress[index];
	}

	//返回数组容量
	int getCapacity()
	{
		return this->m_Capacity;
	}
	//返回数组大小
	int getSize()
	{
		return this->m_Size;
	}
	//析构函数
	~MyArray()
	{
		if (this->pAddress != NULL)
		{
			//cout << "Myarray析构函数调用" << endl;
			delete[] this->pAddress;
			this->pAddress = NULL;
		}
	}

private:

	T * pAddress;  //指针指向堆区开辟的真实数组

	int m_Capacity; //数组容量

	int m_Size; //数组大小

};

#include<iostream>
using namespace std;
#include "MyArray.hpp"
#include <string>

void printIntArray(MyArray <int>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << arr[i] << endl;
	}
}

void test01()
{
	MyArray <int>arr1(5);
	
	for (int i = 0; i < 5; i++)
	{
		//利用尾插法向数组中插入数据
		arr1.Push_Back(i);
	}
	cout << "arr1的打印输出为： " << endl;

	printIntArray(arr1);

	cout << "arr1的容量为： " << arr1.getCapacity() << endl;
	cout << "arr1的大小为： " << arr1.getSize() << endl;

	MyArray <int>arr2(arr1);//拷贝构造，深拷贝

	cout << "arr2的打印输出为： " << endl;

	printIntArray(arr2);

	//尾删
	arr2.Pop_Back();
	cout << "arr2尾删后：" << endl;
	cout << "arr2的容量为： " << arr2.getCapacity() << endl;
	cout << "arr2的大小为： " << arr2.getSize() << endl;

	//MyArray <int>arr3(100);
	//arr3 = arr1;//清空原来的100，再赋值
}

//测试自定义数据类型
class Person
{
public:

	Person() {};
	Person(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	string m_Name;
	int m_Age;
};

void printPerosnArray(MyArray<Person>& arr)
{
	for (int i = 0; i < arr.getSize(); i++)
	{
		cout << "姓名： " << arr[i].m_Name << " 年龄： " << arr[i].m_Age << endl;
	}
}

void test02()
{
	MyArray<Person> arr(10);

	Person p1("孙悟空", 999);
	Person p2("韩信", 30);
	Person p3("妲己", 20);
	Person p4("赵云", 25);
	Person p5("安其拉", 27);

	//将数据插入到数组中
	arr.Push_Back(p1);
	arr.Push_Back(p2);
	arr.Push_Back(p3);
	arr.Push_Back(p4);
	arr.Push_Back(p5);

	//打印数组
	printPerosnArray(arr);
	
	//输出容量 
	cout << "arr容量为： " << arr.getCapacity() << endl;
	//输出大小
	cout << "arr大小为： " << arr.getSize() << endl;
}
int main() {

	//test01();
	test02();
	system("pause");

	return 0;
}

回到顶部

Bigfish_k
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通识-【U007】如何使用Bigfish扩展板-1.概述-资料附件.zip
05-19
通识-【U007】如何使用Bigfish扩展板-1.概述-资料附件.zip
关于今天智能避障机器人的实验
大超人的博客
11-18 2417
智能避障小
制作一个小型三节履带底盘【内附资料下载链接】
Robotway的博客
09-26 1190
双节履带车可以通过两个驱动轮的差速运动来实现前进、后退、原地转向、大半径转向等基本行驶功能，并可通过舵机关节模块进行小臂的抬起和落下。通过底盘运动与小臂运行的结合，实现上台阶、通过坑洼地面等功能。
Bigfish的重新安装
weixin_33749242的博客
08-21 546
昨天把ofbiz安装并成功运行起来，今天接着再把bigfish下载下来。 上次安装配置bigfish时，记得是费了一番周折的，最后也不知道怎么瞎折腾，最终居然跑起来了。 今天有意识整理了下关键步骤，记录在这里。 下载最新的bigfish版本 官网http://bigfish.salmonllc.com/bfDownload.html 给出了多个类型的安装，包括直接使用i...
C++类模板与模板类深入详解
09-04
2. 类模板： 类模板是一种元编程工具，它定义了一种模式，允许用户创建具有可变数据类型的类。类模板并不直接创建一个类，而是定义了一个模板，当提供具体类型时，模板会被实例化成一个具体的类。例如： ```cpp ...
类模板实现矩阵类
12-28
在C++编程中，类模板是一种强大的工具，它允许我们创建通用的类，适用于各种数据类型。本主题将深入探讨如何使用类模板来实现一个矩阵类，以处理二维数组的操作，如存储、输出以及计算矩阵的行数、列数和元素最大值...
Chain模板的定义.rar_模板类
09-21
2. **链表类（List Class）**：这个类提供了链表的操作接口，如插入、删除、遍历等。同样，链表类也是模板化的，以便处理不同类型的元素： ```cpp template class Chain { public: // 构造函数、析构函数、...
分类产品商城网页模板
01-21
这类模板通常包含了各种页面元素和设计组件，如导航栏、商品展示区、购物车、用户登录注册模块等，旨在提升用户体验并促进销售。 一、分类设计 分类设计是商城网页模板的核心部分，它允许用户根据产品类型进行筛选...
软件类的简历模板.zip
04-08
"软件类的简历模板.zip"提供了一组专为软件专业人员设计的简历模板，帮助求职者快速构建吸引人的简历，突出他们在编程、系统分析、项目管理等方面的专业能力。这些模板通常包括清晰的结构、专业的排版以及对关键技能...
MATLAB学习技巧第二部分
08-23
这个资源当时费了很大力气搞到的，总共分为四个部分，喜欢请点赞，谢谢
bigfish
10-24
bigfish
BigFish 文档
10-20
非常棒的电子商务框架，基于Java， 原版文档
BigFish Open Source eCommerce-开源
05-10
BigFish是一种世界一流的解决方案，它利用了开放商务（OFBiz）开源项目的功能。 BigFish扩展了OFBiz。 扩展，增强和简化。 从我们在提供电子商务解决方案方面的多年经验，我们已经了解了什么需要成为坚实稳定的基础，以及哪些功能需要开放和灵活。
GAN网络进展
BigFish_yukang的专栏
02-28 1960
Model 　　1、Unsupervised learning 　　首先我们从generative model说起。generative model的目的是找到一个函数可以最大的近似数据的真实分布。如果我们用 f(X; ??) 来表示这样一个函数，那么找到一个使生成的数据最像真实数据的 ?? 就是一个maximum likelihood estimation的过程。问题在于，当数据的分
前端脚手架BigFish
热门推荐
QuinnNorris的博客
12-06 1万+
Bigfish 企业级前端开发框架，与常见的前端框架和工具不同，它从工程角度集成了各类功能，从初始化开发到最终上线整套技术方案，解决了前端开发经常遇到的前端技术栈整合配置麻烦、开发联调麻烦、前端资源发布上线麻烦三大痛点。 Bigfish主要具备以下功能： 基于 umi 整合了前端工具链：整合了 Ant Design、Dva、Ant Design Pro 技术栈，最小化成本开发 简...
树莓派扩展板（万用板）
bona020的专栏
11-27 8180
经常用到树莓派，做了一些树莓派扩展板用于实验，先上图： 引出20*2排针DC55电源接口电源灯 GPIO灯带上拉IIC传感器接口SPI接口（NRF24L01无线模块接口）  红外接收头封装microusb 封装2.54MM万用板可自行焊接所需电路 有需要的可以TB看： https://item.taobao.com/item.htm?spm=a1z10.3-c
制作一个舵机夹爪模组【内附资料下载链接】
Robotway的博客
09-01 891
夹爪模组的主要运动模式为张开以及闭合。
制作一个轮式机械臂小车【内附资料下载链接】
Robotway的博客
10-09 1522
轮式机械臂小车是一款搭载了机械臂的双轮小车。它的底盘具备基本的行驶和原地转向功能，机械臂具备抬升、放下、抓取等功能。整体上可以实现抓取、搬运、码放等功能，可作为搬运机器人、排爆机器人等的模型使用。
C++中的模板包括： A. 对象模板和函数模板 B. 对象模板和类模板 C. 函数模板和类模板 D. 变量模板和对象模板
最新发布
06-03
2. 函数模板和类模板：函数模板用于定义通用的函数，可以适用于多种数据类型，例如 STL 中的算法函数。类模板用于定义通用的类，可以适用于多种数据类型，例如 STL 中的容器类。 例如，下面是一个用于存储任意类型...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值