C++中模板的那些事儿

最新推荐文章于 2022-04-24 10:25:54 发布
最新推荐文章于 2022-04-24 10:25:54 发布
阅读量988 收藏
点赞数 1
分类专栏： 数据结构 C/C++ 数据结构C++版 文章标签： C++模板 类型萃取 顺序表实现栈 链表实现队列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34328833/article/details/52334873
版权

 C++模板的知识实现顺序表

      模板：是泛型编程的基础

      泛型编程：编写与类型无关的逻辑代码

      说白了模板其实就是一个模具，它是在使用传类型时才存在一个推演的过程，简单的一个模板类的推演过程如下：

     

      

 用模板的方式实现顺序表：

        

#pragma once
#include<iostream>
#include<string>
using namespace std;

template<typename T>
class SeqList
{
	template<typename S>
	friend ostream& operator<<(ostream& os,SeqList<S>& d);
public:
	SeqList();
	SeqList(const SeqList& seq);
	SeqList<T> &operator=(SeqList seq);
	T& operator[](const T& index);
	~SeqList();
public:
	void PushBack(const T& t);
	void PopBack();
	void PushFront(const T& t);
	void PopFront();
	int FindNum(const T& x);
	void Insert(int pos,const T& x);
	void Remove(const T& x);
	void RemoveAll(const T& x);
	void Sort();
	void Display();
public:
	void Reserve(size_t len);
	size_t Size()
	{
		return _size;
	}
	T *_data;
private:
	void CheckCapacity(int count);
	void Copy(T *dest,T *src,int sz);
	size_t GetCapacity()
	{
		return _capacity;
	}
private:
	int _size;
	int _capacity;
};

template<class S>
ostream& operator<<(ostream& os,SeqList<S>& d)
{
	for(int i=0;i<d._size;i++)
	{
		os<<d._data[i]<<" ";
	}
	return os;
}

template<typename T>
SeqList<T>::SeqList()
	:_size(0)
	,_capacity(3)
	,_data(0)
{
	_data=new T[_capacity];
}

template<typename T>
SeqList<T>::SeqList(const SeqList& seq)
{
	T *tmp=new T[seq._capacity];
	for(int i=0;i<seq._size;i++)
	{
		tmp[i]=seq._data[i];
	}
	_data=tmp;
	_size=seq._size;
	_capacity=seq._capacity;
}

template<typename T>
SeqList<T> &SeqList<T>::operator=(SeqList seq)
{
	std::swap(seq._data,_data);
	std::swap(seq._size,_size);
	std::swap(seq._capacity,_capacity);
	return *this;
}

template<typename T>
T& SeqList<T>::operator[](const T& index)
{
	return _data[index];
}

template<typename T>
SeqList<T>::~SeqList()
{
	if(_data != NULL)
	{
		delete[]_data;
		_data=0;
		_size=0;
		_capacity=0;
	}
}

template<typename T>
void SeqList<T>::Display()
{
	for(int i=0;i<_size;i++)
	{
		cout<<_data[i]<<" ";
	}
	cout<<endl;
}

template<typename T>
void SeqList<T>::Reserve(size_t len)
{
	if(GetCapacity() <= len)
	{
		CheckCapacity(len);
	}
	else
	{
		return ;
	}
}

template<typename T>
void SeqList<T>::Copy(T *dest,T *src,int sz)
{
	if(TypeTraits<T>::_IsPodType().Get())
	{
		for(int i=0;i<sz;i++)
		{
			dest[i]=src[i];
		}
	}
	else
	{
		memcpy(dest,src,sz*sizeof(T));
	}
}

template<typename T>
void SeqList<T>::CheckCapacity(int count)
{
	//cout<<typeid(T).name()<<endl;
	if(_size == _capacity)
	{
		int NewCapacity=(2*_capacity)>(_capacity+count)?(2*_capacity):(_capacity+count);
		T *tmp=new T[NewCapacity];
		Copy(tmp,_data,_size);
		delete[]_data;
		_data=tmp;
		_capacity=NewCapacity;
	}
}

template<typename T>
void SeqList<T>::PushBack(const T& t)
{
	CheckCapacity(1);
	_data[_size]=t;
	_size++;
}

template<typename T>
void SeqList<T>::PopBack()
{
	if(_data != 0)
	{
		_size--;
	}
}

template<typename T>
void SeqList<T>::PushFront(const T& t)
{
	CheckCapacity(1);
	for(int i=_size-1;i>=0;i--)
	{
		_data[i+1]=_data[i];
	}
	_data[0]=t;
	_size++;
}

template<typename T>
void SeqList<T>::PopFront()
{
	for(int i=0;i<_size;i++)
	{
		_data[i]=_data[i+1];
	}
	_size--;
}

template<typename T>
int SeqList<T>::FindNum(const T& x)
{
	for(int i=0;i<_size;i++)
	{
		if(_data[i] == x)
			return i;
	}
	return -1;
}

template<typename T>
void SeqList<T>::Insert(int pos,const T& x)   //在指定位置的前面插入元素
{
	CheckCapacity(1);
	for(int i=_size-1;i>=pos;i--)
	{
		_data[i+1]=_data[i];
	}
	_data[pos]=x;
	_size++;
}

template<typename T>
void SeqList<T>::Remove(const T& x)    //删除指定元素
{
	int ret=FindNum(x);
	if(ret != -1)
	{
		for(int i=ret;i<_size-1;i++)
		{
			_data[i]=_data[i+1];
		}
		_size--;
	}
	else
	{
		return ;
	}
}

template<typename T>
void SeqList<T>::RemoveAll(const T& x)   //删除所有指定元素
{
	while(_size != 0)
	{
		int ret=FindNum(x);
		if(ret != -1)
		{
			for(int i=ret;i<_size-1;i++)
			{
				_data[i]=_data[i+1];
			}
			_size--;
		}
		else
		{
			break;
		}
	}
}

template<typename T>
void SeqList<T>::Sort()
{
	int flag=1;
	int m=0;
	int k=0;
	for(int i=0;i<_size-1;i++)
	{
		for(int j=0;j<=k;j++)
		{
			if(_data[i] > _data[i+1])
			{
				T tmp=_data[i];
				_data[i]=_data[i+1];
				_data[i+1]=tmp;
				flag=0;
				m=j;     //m用来记录上一次交换完成的位置
			}
			k=m;
		}
		if(flag == 1)
			break;
	}
}

 

 模板的模板参数-容器适配器
   我们知道栈是先进后出的一种数据结构，而如果我们要模拟实现栈的这种数据结构我们发现顺序表是最好的选择，因为效率高，栈的插入和删除正好对应的是顺序表的尾插和尾删

    

//模板参数
//template<class T,class Container=SeqList>
//模板的模板参数
template<class T,template<class>class Container=SeqList>
class Stack
{
public:
	void Push(const T& d)
	{
		_con.PushBack(d);
	}
	void Pop()
	{
		_con.PopBack();
	}
	bool Empty()
	{
		return _con.Size() == 0;
	}
	T& Top()
	{
		int sz=_con.Size();
		return _con._data[--sz];
	}
	void Display()
	{
		while(!Empty())
		{
			cout<<Top()<<" ";
			Pop();
		}
		cout<<endl;
	}
private:
	Container<T> _con;
};


测试代码：

   

void test5()
{
	Stack<int> s;
	s.Push(1);
	s.Push(2);
	s.Push(3);
	s.Push(4);
	s.Push(5);
	s.Display();
}


 

 类型萃取的实例应用一：SeqList

        类型萃取其实就是区分内置类型和自定义类型

       

#define _CRT_SECURE_NO_WARNINGS 1
struct _TrueType
{
	int Get()
	{
		return 1;
	}
};

struct _FalseType
{
	int Get()
	{
		return -1;
	}
};

template<typename T>  //自定义类型
struct TypeTraits
{
	typedef _FalseType _IsPodType;
};

template<>    //内置类型
struct TypeTraits<int>
{
	typedef _TrueType _IsPodType;
};

template<>
struct TypeTraits<double>
{
	typedef _TrueType _IsPodType;
};

template<>
struct TypeTraits<char>
{
	typedef _TrueType _IsPodType;
};

template<typename T>
void Copy(T *dest,T *src,int sz,_TrueType)
{
	memcpy(dest,src,sz*sizeof(T));
}

template<typename T>
void Copy(T *dest,T *src,int sz,_FalseType)
{
	for(int i=0;i<sz;i++)
	{
		dest[i]=src[i];
	}
}

template<typename T>
void Copy(T *dest,T *src,int sz)
{
	if(TypeTraits<T>::_IsPodType().Get())
	{
		for(int i=0;i<sz;i++)
		{
			dest[i]=src[i];
		}
	}
	else
	{
		memcpy(dest,src,sz*sizeof(T));
	}
}


测试代码：

   

void testTypeTraits()
{
	string s1[10]={"abcd","bcde","defg","bbbxxxxxxxxxxxxxxxxxxxxx"};
	string s2[10]={"12","23","34","45"};
	Copy(s1,s2,10,TypeTraits <string>::_IsPodType());
	Copy(s1,s2,10);
	int a1[10]={1,2,3};
	int a2[10]={0};
	Copy(a1,a2,10,TypeTraits <int>::_IsPodType());
	Copy(a1,a2,10);
}


C++模板的知识实现链表：

     C++实现链表：

 

#pragma once
#include<cstring>
#include<iostream>
using namespace std;

template<typename T>
struct Node
{
	template<typename T>
	friend ostream& operator<<(ostream& os,Node<T>& n)
	{
		os<<n._data;
		return os;
	}
public:
	Node(const T& d)
		:_next(NULL)
		,_front(NULL)
		,_data(d)
	{}
	T _data;
	Node<T>* _next;
	Node<T>* _front;
};

template<typename T>
class LinkList
{
	template<typename T>
	friend ostream& operator<<(ostream& os,LinkList<T>& list);
public:
	LinkList()
		:_head(0)
		,_tail(0)
	{}
	LinkList(const LinkList<T>& list);
	LinkList<T>& operator=(LinkList<T> list);
	~LinkList();
public:
	void PushBack(const T& d);
	void PopBack();
	void PushFront(const T& d);
	void PopFront();
	Node<T> *FindNum(const T& x);
	void Insert(Node<T> *pos,const T& x);
	void Insert(int,Node<T> *pos,const T& x);
	void Remove(const T& x);
	void RemoveAll(const T& x);
	void Sort();
	void Display()
	{
		Node<T>* cur=_head;
		while(cur)
		{
			cout<<cur->_data<<" ";
			cur=cur->_next;
		}
		cout<<endl;
	}
public:
	Node<T>* GetFront()
	{
		return _head;
	}
	Node<T>* GetTail()
	{
		return _tail;
	}
	size_t Size();
private:
	Node<T> *_head;
	Node<T> *_tail;
};

template<typename T>
ostream& operator<<(ostream &os,LinkList<T> &list)
{
	Node<T> *cur=list._head;
	while(cur)
	{
		os<<(*cur)<<" ";
		cur=cur->_next;
	}
	return os;
}

template<typename T>
LinkList<T>::LinkList(const LinkList<T>& list)
	:_head(0)
	,_tail(0)
{
	Node<T>* cur=list._head;
	while(cur)
	{
		PushBack(cur->_data);
		cur=cur->_next;
	}
}

template<typename T>
LinkList<T>& LinkList<T>::operator=(LinkList<T> list)
{
	std::swap(list._head,_head);
	std::swap(list._tail,_tail);
	return *this;
}

template<typename T>
LinkList<T>::~LinkList()
{
	Node<T>* cur=_head;
	while(cur != 0)
	{
		Node<T>* del=cur;
		cur=cur->_next;
		delete del;
		del=NULL;
	}
	_head=NULL;
	_tail=NULL;
}

template<typename T>
void LinkList<T>::PushBack(const T& d)
{
	Node<T> *NewNode=new Node<T>(d);
	if(_head == NULL)
	{
		_head=NewNode;
		_tail=NewNode;
	}
	else
	{
		_tail->_next=NewNode;
		NewNode->_front=_tail;
		_tail=NewNode;
	}
}

template<typename T>
void LinkList<T>::PopBack()
{
	if(!_head)    //空链表
	{
		return ;
	}
	else if(!_head->_next)     //只有一个节点
	{
		delete _tail;
		_head=NULL;
		_tail=NULL;
	}
	else      //至少存在两个节点
	{
		_tail=_tail->_front;
		delete _tail->_next;
		_tail->_next=0;
	}
}

template<typename T>
void LinkList<T>::PushFront(const T& d)
{
	Node<T> *NewNode=new Node<T>(d);
	if(_head)
	{
		Node<T> *tmp=_head;
		NewNode->_next=tmp;
		tmp->_front=NewNode;
	}
	else    //空链表
	{
		_tail=NewNode;
	}
	_head=NewNode;    //更新头
}

template<typename T>
void LinkList<T>::PopFront()
{
	if(!_head)    //空链表
	{
		return ;
	}
	else if(!_head->_next)  //只有一个结点
	{
		delete _head;
		_head=NULL;
		_tail=NULL;
	}
	else         //至少存在两个结点
	{
		_head=_head->_next;
		delete _head->_front;
		_head->_front=NULL;
	}
}

template<typename T>
Node<T> *LinkList<T>::FindNum(const T& x)
{
	Node<T> *cur=_head;
	while(cur)
	{
		if(cur->_data == x)
			return cur;
		cur=cur->_next;
	}
	return NULL;
}

template<typename T>
void LinkList<T>::Insert(Node<T> *pos,const T& x)    //在指定位置后插
{
	Node<T> *NewNode=new Node<T>(x);
	if(pos->_next)
	{
		NewNode->_front=pos;
		NewNode->_next=pos->_next;
		pos->_next->_front=NewNode;
		pos->_next=NewNode;
	}
	else    //在最后一个结点后插，类似PushBack
	{
		pos->_next=NewNode;
		NewNode->_front=pos;
		_tail=NewNode;    //更新尾
	}
}

template<typename T>
void LinkList<T>::Insert(int,Node<T> *pos,const T& x)   //在指定位置前插
{
	Node<T> *NewNode=new Node<T>(x);
	if(pos->_front)
	{
		NewNode->_next=pos;
		pos->_front->_next=NewNode;
		NewNode->_front=pos->_front;
		pos->_front=NewNode;
	}
	else   //在第一个结点的前插，类似PushFront
	{
		NewNode->_next=pos;
		pos->_front=NewNode;
		_head=NewNode;    //更新头
	}
}

template<typename T>
void LinkList<T>::Remove(const T& x)
{
	Node<T> *pos=this->FindNum(x);
	if(pos != 0)
	{
		if((!(pos->_front)) && pos->_next)    //删除第一个结点
		{
				Node<T> *tmp=pos->_next;
				tmp->_front=NULL;
				_head=tmp;
		}
		else if(pos->_front && (!(pos->_next)))   //删除最后一个结点
		{
			Node<T> *tmp=pos->_front;
			tmp->_next=NULL;
			_tail=tmp;
		}
		else             //删除中间节点
		{
			Node<T> *front=pos->_front;
			Node<T> *next=pos->_next;
			next->_front=front;
			front->_next=next;
		}
		delete pos;
		pos=0;
	}
}

template<typename T>
void LinkList<T>::RemoveAll(const T& x)
{
	Node<T> *cur=_head;
	Node<T> *ret=this->FindNum(x);
	if(ret != _head)    //可删除第一个结点不是要删除的元素
	{
		while(cur)
		{
			Remove(x);
			cur=cur->_next;
		}
	}
}

template<typename T>
void LinkList<T>::Sort()
{
	int flag=1;
	Node<T> *cur=_head;
	Node<T> *tail=NULL;
	while(cur != tail)
	{
		while(cur->_next != tail)
		{
			if(cur->_data > cur->_next->_data)
			{
				T tmp=cur->_data;
				cur->_data=cur->_next->_data;
				cur->_next->_data=tmp;
				flag=0;
			}
			cur=cur->_next;
		}
		if(flag == 1)
			break;
		tail=cur;
		cur=_head;
	}
}

template<typename T>
size_t LinkList<T>::Size()
{
	Node<T>* cur=_head;
	size_t count=0;
	while(cur)
	{
		count++;
		cur=cur->_next;
	}
	return count;
}


  模板参数-容器适配器

   借用链表的某些函数实现队列这种数据结构，队列：先进先出，之所以使用链表的方式而不使用顺序表，因为顺序表在插入一个元素时需要大量移动元素而链表则不需要，我们发现针对队列的这种数据结构，它的插入和删除则正好对应链表的尾插和头删

   

//模板参数
template<class T,class Container=LinkList>
class Queue
{
public:
	void Push(const T& d)
	{
		_con.PushBack(d);
	}
	void Pop()
	{
		_con.PopFront();
	}
	Node<T>& Front()
	{
		return *_con.GetFront();
	}
	Node<T>& Back()
	{
		return *_con.GetTail();
	}
	bool Empty()
	{
		return _con.GetFront() == 0;
	}
	size_t Size()
	{
		return _con.Size();
	}
	void Display()
	{
		while(!Empty())
		{
			cout<<Front()._data<<" ";
			Pop();
		}
		cout<<endl;
	}
private:
	Container _con;
};


 测试代码：

  

void testQueue()
{
	Queue<int,LinkList<int>> q1;
	q1.Push(1);
	q1.Push(2);
	q1.Push(3);
	q1.Push(4);
	q1.Push(5);
	cout<<q1.Size()<<endl;   //5
	q1.Display();
}

 

      如果对模板还有兴趣请观赏《C++ templates》这本书，Thanks

CTTCassie
关注
专栏目录
C++模板那些事儿
caoDanLife的博客
07-23 120
C++模板那些事儿初识模板为什么使用模板函数模板类模板 初识模板 C++有个概念叫泛型编程，即编写与类型无 ，关的通用代码。模板就是其实现基础。模板分为函数模板和类模板。模板不支持分离编译，也就是声明在.h文件中，定义在.cpp中。 为什么使用模板 模板可以具有非类型参数，用于指定大小，可以根据指定的大小创建动态结构 模板最重要的一点就是类型无关，提高了代码复用性 模板运行时不检查数据类型，也不保证类型安全，相当于类型的宏替换 只要支持模板语法，模板的代码就是可移植的 函数模板 template &lt
C++模板类string那点事儿
caoDanLife的博客
07-25 323
C++模板类string那点事儿初识string常用string接口迭代器reserve和resize模拟实现string增删查改增尾插头插/中间插入删查改string相关算法 初识string string是STL(Standard Template Library)标准模板库提供的一个容器，官方定义如下： 可见string只是basic_string的一个模板类。 常用string接口 接口 说明 string(const string& str) 拷贝构造函数 stri
模板编程总结
纯，属虚构
09-12 800
1、template //template parameter list 2、模版形参可以表示类型形参，也可以表示常量表达式的非类型形参。 3、使用函数模版时，编译器会推断出哪个或哪些模版实参绑定到模版形参。一旦编译器确定了实际的模版实参，就称它实例化了函数模版的一个实例。 4、inline 只能放在template 5、类型形参也存在屏蔽问题。模版形参的名字只能在同一个列表中出现一次，但
数据结构（六）之线性表
海是倒过来的天的博客
04-04 736
1.1 线性表 1.1.1 生活中的线性表 幼儿园小朋友排队的情况 1.1.2 线性表的表现形式 零个或多个元素组成的集合 数据元素在位置上是有序排列的 数据元素的个数是有限的 数据元素的类型必须相同 1.1.3 线性表（List）的抽象定义 线性表是具有相同类型的n(n>= 0)个数据元素的有限序列 (a0， a1 , 。。。 an) ai 是表项（数据元素），n是表长度 1...
模板(template)使用介绍
热门推荐
qq_24946843的博客
03-31 1万+
我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数类型的不同及所属类的不同，正确的调用重载函数。例如，为求两个数的最大值，我们定义max()函数需要对不同的数据类型分别定义不同重载(Overload)版本。 但如果在主函数中，我们分别定义了char a,b;那么在执行max(a,b);时 程序就会出错，因为我们没有定义char类型的重载版本。现在，我们...
函数模板中使用二维数组作为参数时的技巧
毛毛(handsomerun)的专栏
04-06 3543
有多个非常相似的函数，只是参数的第2唯长度不一样，如：void F(int a[][10],int b[][10]){}void F1(int a[][20],int b[][20]){}用函数模板来实现，template void TF(int aa[][len],int bb[][len])看似没有问题，但是编译的时候会报错error C2087: : missing
线性表实现整数求和
qq_16785653的博客
04-24 253
#include<iostream> using namespace std; const int Max_size = 100; //顺序表的最大长度 template<typename T> class SeqList{ public: SeqList():length_(0){} SeqList(T*input_array,int length); ~SeqList(){}; int Length(); void Ins.
[C++]1.20 模板那些事儿
easycome easygoing、
01-20 342
函数-模板 函数模板不是万能的，且不能单独使用。C++的一种编程思想叫泛型编程，利用的一个重要技术就是模板。C++提高两种模板机制：类模板和函数模板。 应用场景：通过类型参数化提高函数复用性 函数模板作用：建立一个通用函数，函数返回值和参数类型可以不定，用一个虚拟类型来代表。 函数声明语法： template<typename T> template：声明创建模板；typename：证明它后面是一种模板类型（可以用class代替） T：通用数据类型 两种使用方法： 1.自动类型.
C++标准模板库函数sort的那些事儿
01-20
C++中的`sort`函数是标准模板库(STL)的一部分，位于`<algorithm>`头文件中，它提供了一种高效且灵活的方式来对各种容器中的元素进行排序。`sort`函数的默认行为是对指定范围内的元素进行升序排列，但通过自定义比较...
C++头文件和变量的那些事儿
weixin_49007080的博客
04-14 1029
关于C++的头文件、内存中的变量，命名空间，new关键字
C++ 模板类函数——ostream 006:我自己的 ostream_iterator
BLUEsang的博客
03-31 581
描述 程序填空输出指定结果 #include <iostream> #include <list> #include <string> using namespace std; template <class T1,class T2> void Copy(T1 s,T1 e, T2 x) { for(; s != e; ++s,++x) *x...
使用类模板取数组长度
weixin_34406086的博客
03-26 142
template<typenameT,intlen>size_tarraylen(T(&arr)[len]){returnlen;}intmain(){inta[]={1,2,3,4,5,6};printf("arraylength:%d",arraylen(a));retu...
线性表——顺序表与单链表（模板）
csdn_lfy的博客
04-16 216
#include <iostream> using namespace std; const int MaxSize=100; template <typename T> class SeqList { private: int length; T data[MaxSize]; public : SeqList(); SeqList(...
数据结构之线索二叉树的前序,中序和后序遍历
微风
10-09 1万+
BinaryTree线索化二叉树      二叉树是一种非线性结构，在之前实现的二叉树遍历中不管是递归还是非递归用二叉树作为存储结构时只能取到该结点的左孩子和右孩子，不能得到该结点的前驱和后继。为了保存这种在遍历中需要的信息，同时也为了充分利用结点中的空指针域，我们利用二叉树中指向左右子树的空指针来存放结点的前驱和后继.同时在有n个结点的二叉链表中必定存在n+1个空链域.      那仫问题来
一个简单的迷宫算法
微风
09-11 1万+
迷宫问题的求解是一个典型的问题，那仫如何找到迷宫的出口？在遇到死胡同的时候如何返回？如何防止走重复的路程？这就是我们要解决的问题了.      一.设置迷宫          要打印一个简单的迷宫，我们理所当然的想到了利用二维数组，在迷宫的实现中我定义了一个MazeMap.txt的文件用来存储迷宫，在初始化的时候只需要将该迷宫从mazeMap.txt中读出来就可以了.        0-路
复数类的完整实现(C++版)
微风
08-04 1万+
如果你想成功就去努力，不要让你的懒惰埋葬了你的梦想
浅析B树的分裂过程
微风
11-12 1万+
B-树>      最近一直在研究树的这种数据结构，今天实现了一颗适合外查找的平衡多叉树就是B树，有的地方也叫B-树(不要误读为"B减树"奥).当然了还存在B+树，B*树这里只实现B树  一.B树的性质>      一颗M阶(M>2)的B树，是一颗平衡的M路平衡搜索树，可以是空树或者满足下面几条性质>      1).根结点至少有两个孩子.      2).每个非根结点存在[M/2,M)
浅谈main函数的栈帧
微风
07-01 6446
相信自己没有什仫困难是不能克服的，人只有在步入绝境的时候才会发挥无限的潜力
C++标准模板库深入解析与应用
"C++标准模板库相关资源，包括《C++ Standard Library》一书的中文翻译，由侯捷和孟岩合译。该资源提供了对C++标准模板库的深入理解和学习，涵盖STL的基础知识和高级应用。" C++标准模板库(C++ Standard Library)是...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值