C++模板和STL

已于 2022-03-15 16:34:32 修改
阅读量541 收藏 3
点赞数
分类专栏： C C++ Linux 文章标签： c++ c语言 后端
于 2022-03-07 16:16:39 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_41560737/article/details/123333099
版权

C++模板和STL

在这里插入图片描述

模板

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

函数模板的定义

在这里插入图片描述
在这里插入图片描述

例：

#include <iostream>
using namespace std;

//函数模板,"T"类型形参
template <typename T>   //推荐使用typename 
//template <class T>
T max(T x, T y){
   
  return x<y?y:x;
}
int main(void){
   
  int  i1=100,i2=200;
  // "<>"指明函数模板需要的类型实参
  // "()"指明函数的调用实参
  cout<<::max<int>(i1,i2)<<endl;

  double d1=1.23,d2=4.56;
  cout<<::max<double>(d1,d2)<<endl;

  string s1="world",s2 = "hello";
  cout<<::max<string>(s1,s2)<<endl;

  char str1[] = "world";
  char str2[] = "hello";
  cout<<::max<string>(str1,str2)<<endl;
  return 0;

}

函数模板的使用

在这里插入图片描述

模板实例化

在这里插入图片描述

类型参数

在这里插入图片描述

参考代码：

#include <iostream>
using namespace std;
template <typename T>
T add(T x,T y){
   
  return x+y;
}
class Complex{
    //复数
public:
      Complex(int r,int i):m_r(r),m_i(i){
   }
      //cout<<c1==>operator<<(cout,c1)	
      friend ostream& operator<<(ostream& os,const Complex& c){
   
        os<<c.m_r<<"+" <<c.m_i<<"i";
	return os;
      }
      //重载+ (成员函数形式)
      //c1+c2 ==>c1.operator(c2)
      const Complex operator+(const Complex& c)const{
   
        Complex res(m_r+c.m_r,m_i+c.m_i);
	return res;
      }
private:
      int m_r;
      int m_i;
};

int main(void){
   
  cout<<add<int>(123,456)<<endl;
  cout<<add<double>(1.23,4.56)<<endl;
  Complex c1(1,2);
  Complex c2(3,4);
  cout<<c1<<","<<c2<<endl;
  cout<<add<Complex>(c1,c2)<<endl;  //4+6i
}

二次编译

在这里插入图片描述
在这里插入图片描述

函数模板的隐式推断

在这里插入图片描述
在这里插入图片描述

参考代码：07deduce.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template <typename A,typename V>
void func1(A arg){
   
  V var;
  cout <<"调用参数类型："<<typeid(arg).name()<<endl;
  cout <<"局部变量类型："<<typeid(var).name()<<endl;
}

template <typename T>
void func2(T x,T y){
   
  cout<<"参数x类型："<<typeid(x).name()<<endl;
  cout<<"参数y类型: "<<typeid(y).name()<<endl;
}

template <typename T1,typename T2>
T1 func3(T2 x){
   
  T1 y;
  cout <<"参数x类型:"<<typeid(x).name()<<endl;
  cout <<"返回y类型:"<<typeid(y).name()<<endl;
  return y;
}

int main(void){
   
   //func1(100); //error
   func1<int,int>(11); //ok

   //func2(100,1.23); //error
   func2<int>(100,1.23);  //显示推断。隐式转换
   func2<double>(100,1.23);

   func2(100,(int)1.23) ; //显示转换，隐式推断
   func2((double)100,1.23);

   //double d = func3(100); //error
   double d = func3<double>(100); //显式指明返回类型，隐式推断参数类型
}

在这里插入图片描述

函数模板的重载

在这里插入图片描述
参考代码：07overload.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template <typename T>
void func(T x, T y){
    //针对两个任意类型的数据：约束性一般
        cout<<"func(1),type="<<typeid(T).name()<<endl;
}
template <typename T>
void func(T* x,T* y){
   
   cout<<"func(2),type="<<typeid(T).name()<<endl;
}
int main(void){
   
  int a = 10,b = 20;
  func(a,b) ;  //func(1) ,T = int
  func(&a,&b); //func（2）,T = int
  func<int*>(&a,&b);  //func(1) ,T= int*
  return 0;
}

参考代码2: 08overload.cpp

#include <iostream>
#include <typeinfo>
using namespace std;

template <typename T>
void func(T x, T y){
    //针对两个任意类型的数据：约束性一般
	cout<<"func(1),type="<<typeid(T).name()<<endl; 
}
template <typename T>
void func(T* x,T* y){
   
   cout<<"func(2),type="<<typeid(T).name()<<endl;
}

void func(const char* x,const char* y){
    //针对性两个const char *:约束性更强
  cout<<"func(3),type="<<typeid(x).name()<<endl;
}

int main(void){
   
  int a = 10,b = 20;
  func(a,b) ;  //func(1) ,T = int
  func(&a,&b); //func（2）,T = int
  func<int*>(&a,&b);  //func(1) ,T= int*

  const char* s1 = "123";
  const char* s2 = "456";
  func(s1,s2); //func(3);
  func<>(s1,s2);  //func(2)
  //如果匹配func(2),类型实参const char*,调用参数类型应该式const char**,无法和调用实参s1，s2
  //相匹配，所以只能选中第一个版本
  func<const char*>(s1,s2); //func(1)


  return 0;
}

在这里插入图片描述

类模板的定义

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

类模板的使用

在这里插入图片描述

类模板的实例化

在这里插入图片描述

类模板中的成员函数

在这里插入图片描述

参考代码：09ct.cpp

 #include <iostream>
using namespace std;

template <typename T>
class Compare{
    //类模板
public:
	Compare(T x,T y):m_x(x),m_y(y){
   }
	T max(void) const{
   
           return m_x < m_y ? m_y:m_x;	
	}
	T min(void) const {
   
           //return m_x >m_y ?m_y:m_x;        	
           //对于类模板的设计者，应该尽可能减少对类型实参的要求，方便类模板的使用者
           return m_x < m_y ? m_x:m_y;	
	}
private:
	T m_x;
	T m_y;
};

class Integer{
   
public:
	Integer(int data):m_data(data){
   }
	friend ostream& operator<<(ostream& os,const Integer& i){
   
           os<<i.m_data;
           return os;	   
	}
	//重载《成员函数形式》
	bool operator<(const Integer& i) const{
   
           return m_data<i.m_data;	
	}
	//重载>（成员函数形式）
	bool operator >(const Integer& i) const{
   
           return m_data>i.m_data;	
	}
private:
	int m_data;
};

int main(void){
   
	//先结合<int>实例化具体的类，再使用该类实例化ci对象
  //Compare<int> ci(123,456);
  //cout<<"max="<<ci.max()<<",min="<<ci.min()<<endl;
  //Compare<double> cd(1.23,4.56);
  //cout<<"max="<<cd.max()<<",min="<<cd.min()<<endl;

  //cout<<sizeof(Compare)<<endl; //error
  //cout<<sizeof(Compare<int>)<<endl;  //ok ,8

  //Compare cc('A','B');  //error
  //Compare<int>ci(123,456);
  //cout<<"max="<<ci.max()<<",min="<<ci.min()<<endl;
  Integer i1(123);
  Integer i2(456);
  Compare<Integer>cInt(i1,i2);//ok
  cout<<"max="<<cInt.max()<<endl;

  return 0;
}

类模板的静态成员

在这里插入图片描述
参考代码：static.cpp

#include <iostream>
using namespace std;

template <typename T>
class A{
   
public:
	void printAddr(void){
   
           cout<<"&m_data:"<<&m_data<<",s_data="<<&s_data<<endl;
	}
private:
	int m_data;  //普通成员变量
	static int s_data; //静态成员便利
};

template <typename T>
int A<T>::s_data; //定义

int main(void){
   
  A<int> i1,i2;
  A<double> d1,d2;
  //一共有几个m_data(4)个?s_data?（2个
  i1.printAddr();
  i2.printAddr();
  d1.printAddr();
  d2.printAddr();
  
}

类模板的递归实例化

在这里插入图片描述
在这里插入图片描述

参考代码：

#include <iostream>
using namespace std;

template <typename T>
class Array{
   
public:
	//下标操作符重载
       T& operator[](size_t i){
   
          return m_a[i] ;
       }
       const T& operator[] (size_t i)const{
   
          return m_a[i] ;
       }
       //获取容器中元素个数
       size_t size(void)const{
   
          return sizeof(m_a)/sizeof(m_a[0]);
       }


       //重载<<
       friend ostream& operator<<(ostream& os,const Array& arr){
   
          for(size_t i=0;i<arr.size();i++) {
   
	     os<<arr[i] <<' ';
	  }
	  return os;
       }

private:
	T m_a[3];
};
int main(void){
   
  Array<int>a1;
  a1[0] = 10;
  a1[1] = 20;
  a1[2] = 30;
  cout<<a1<<endl;
  Array<int>a2;
  a2 = a1;
  cout<<a2<<endl;
  //递归实例化：用类模板实例化的类型，作为类型实参，再实例化该类模板自身
  Array<Array<int> >aa;//二维数组
  for(size_t i=0;i<aa.size();i++)
	  for(size_t j=0;j<aa[i].size();j++)
		  aa[i][j] = i*3+j+1; //1 2 3 4 5 6 7 8 9 
  for(size_t i=0;i<aa.size();i++){
   
     cout<<aa[i] <<endl;
  }
  return 0;
}

类模板的特化

在这里插入图片描述

全类特化

在这里插入图片描述
参考代码：

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

template <typename T>
class Compare{
   
public:
    Compare(T x,T y):m_x(x),m_y(y){
   }
    T Max(void){
   
       cout<<"通用版本" <<endl;
       return m_x<m_y?m_y:m_x;
    }

private:
    T m_x;
    T m_y;
};
template <>
class Compare<char *>{
    //全类特化(针对char *实例化的具体类)
public:
	Compare(char *x,char *y):m_x(x),m_y(y){
   }
	char *Max(void){
   
	   cout<<"特化版本"<<endl;
           return strcmp(m_x,m_y)<0?m_y:m_x;	
	}
private:
    char *m_x;
    char* m_y;
};

int main(void){
   
  Compare<int> cInt(123,456);
  cout<<cInt.Max()<<endl; //456

  char s1[] = "world";
  char s2[] = "hello";
  Compare<char *>cChar(s1,s2);
  cout<<cChar.Max()<<endl; //world

  return 0;
}

成员特化

在这里插入图片描述
参考代码：

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

template <typename T>
class Compare{
   
public:
    Compare (T x,T y):m_x(x),m_y(y){
   }
    T Max(void)const{
   
       cout<<"通用版本" <<endl;
       return m_x<m_y?m_y:m_x;
    }

private:
    T m_x;
    T m_y;
};
template<>
char *Compare<char *>::Max(void)const{
    //成员特化（针对char* 重写的Max函数）
  cout<<"特化版本"<<endl;
  return strcmp(m_x,m_y)<0?m_y:m_x;
}

int main(void){
   
  Compare<int> cInt(123,456);
  cout<<cInt.Max()<<endl; //456

  char s1[] = "world";
  char s2[] = "hello";
  Compare<char *>cChar(s1,s2);
  cout<<cChar.Max()<<endl; //world

  return 0;
}

局部(偏)特化

在这里插入图片描述
在这里插入图片描述

模板的使用技巧

在这里插入图片描述

类模板参数的缺省值

在这里插入图片描述
参考代码：

#include <iostream>
#include <typeinfo>
using namespace std;

template<typename A=double,typename B=A>
class X{
   
public:
	static void foo(void){
   
            cout<<typeid(A).name()<<","<<typeid(B).name()<<endl;	
	}
};

template<typename A=int,typename B=double>
void fun(void){
   
	cout<<typeid(A).name()<<","<<typeid(B).name()<<endl;
}

int main(void){
   
  X<int,int>::foo();
  X<int>::foo();
  X<double>::foo();
  X<>::foo();

  return 0;
}

数值型模板参数(非类型参数)

在这里插入图片描述
参考代码

#include <iostream>
using namespace std;

template<typename T,size_t S=10/*数值型模板参数*/>
class Array{
   
public:
    T& operator[](size_t i){
   
       return m_arr[i] ;
    }
    const T& operator[](size_t i)const{
   
       return m_arr[i] ;
       return const_cast<Array&>(* this) [i];
    }
    size_t size(void) const{
   
      return sizeof(m_arr)/sizeof(m_arr[0] );
    }
    friend ostream& operator<<(ostream& os,const Array& arr){
   
       for(size_t i=0;i<arr
最低0.47元/天 解锁文章
weixin_101
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++模板与STL库介绍
03-18
C++模板与STL库介绍 非常详细
C++——模板与STL标准模板库
qq_52479948的博客
01-19 1261
C++——模板与STL标准模板库
【C++】模板初阶&&STL简介
The porters of knowledge
02-11 1435
泛型编程、函数模板、类模板、STL简介…
【C++】模板和STL库
晚安的博客
02-07 705
本文是我在学习C++过程当中的心得和学习笔记，在学习C++时已经有C语言的基础。文章包含了C++的高阶内容，并附上了学习的代码，仅供大家参考。如果有问题，有错误欢迎大家留言。
C++【模板&&STL简介】
m0_59292239的博客
02-24 748
C++【模板&&STL简介】
04C++中模板和STL介绍
精致的灰的博客
09-21 962
模板和STL是C++比较重要的部分。本章仅做简单了解。 文章目录一、模板1.1.函数模板1.1.1.两种函数模板的实例化1.1.2.模板参数的匹配原则1.2.类模板二、STL 一、模板 对于一个交换函数，虽然C++支持函数重载，我们可以对多个交换函数起相同的名字： void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double& lef
C++模板编程和STL编程
03-18
C++模板编程和STL编程
c++ STL模板
11-08
向量vector是一种随机访问的数组类型，提供了对数组元素的快速、随机访问以及在序列尾部快速、随机的插入和删除操作。它是大小可变的向量，在需要是可以改变其大小。 形式：
C++标准模板库STL初步(1)
02-04
组成的库来说提供了更好的代码重用机会。在C++标准中，STL被组织为下面的几个头文件：、、、、、、、、、、、、和。文件中主要介绍了前面八个的使用，并且重点介绍了他们的属性和一些成员函数的使用。
《C++语言 - 标准模板库STL》_标准模板库_C++_C++STL_
09-29
c++入门资料
学习-＞C++篇五：模板与STL简介
u014801954的博客
08-22 536
1. 函数模板 2. 类模板 3.模板的语法 （1）非类型模板参数 （2) 模板的特化 （3）模板的分离编译 4.STL简介
C++泛型函数学习
hkk1151043545的博客
04-14 3683
1 模板 1.1 模板的概念 1.2 函数模板 1.2.1 函数模板语法 1.2.3 函数模板案例 1.2.4 普通函数与函数模板的区别 1.2.5 普通函数与函数模板的调用规则–可以发送函数重载 1.2.6 模板的局限性 1.3 类模板 1.3.1 类模板语法 1.3.3 类模板中成员函数创建时机 1.3.5 类模板与继承 C++提高编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨...
C++模板和STL的一些知识
jianan7387的博客
05-23 194
STL，standard template library。原博主timebomb：原文链接在这里标准模板库就是类与函数模板的大集合。STL共有6种组件：容器，容器适配器，迭代器，算法，函数对象和函数适配器。1、容器：容器是用来存储和组织其他对象的对象。STL容器类的模板在标准头文件中定义。主要如下所示①序列容器基本的序列容器是上面图中的前三类：关于三者的优缺点主要是：A:vector<T>矢量容器：可以随...
C++标准模板库STL简介
11-10 2725
1. C/C++与STL 1.1. 什么是STL？    STL -- 数据结构和算法的分离，模板（GP）；    STL的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL变得非常通用。例如，由于STL的sort()函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表，容器和数组；    STL另一个重要特性是它不是面向对象的。为了具有足够通用性，
C++ 模板技术和STL实战开发(1)——STL实用编程技术(1)——模板机制剖析
波波鱼的博客
11-21 560
模板 模板把函数或类要处理的数据类型参数化，表现为参数的多态性，成为类属 个人思考：模板也是计算机的很重要的思想“抽象思想”的体现 模板解决的是逻辑结构相同，但具体数据元素类型不同的数据 参数化编程： 参数化编程有效地降低了开发成本，减少了出错概率，这也是模板思想的起源 深入剖析： 问题１：第12行和第15行调的是同一个函数吗？ 函数模板与模板函数的辨析 　　　函数...
C++ ——模板 & 标准模板库STL
Li27的博客
08-20 446
模板，重载的升级版！实际编程当中我们一定要学会熟练使用标准模板库中的工具！
c++（标准模板库STL）
Andrew的博客
05-07 4506
STL是一种泛型编程（genericprogramming） STL提供了一组表示容器、迭代器、函数对象和算法的模板。 面向对象编程关注的是编程的数据方面，而泛型编程关注的是算法。 他们之间的共同点是抽象和创建可重用代码，但是他们的理念截然不同。 1、容器（container） 容器类是一个与数组类似的单元，但是他是管理序列的类，也是容纳一组对象或对象集的类。 通过容器类提供的成员函数...
C++模板与标准模板库（STL库）介绍
ShuaiWangCSDN的博客
02-26 3214
1. 概论  C++ 语言的核心优势之一就是便于软件的重用  C++中有两个方面体现重用：     1. 面向对象的思想：继承和多态，标准类库     2. 泛型程序设计(generic programming) 的思想：模板机制，以及标准模板库机制，以及标准模板库 STL泛型程序设计  泛型程序设计，简单地说就是使用模板的程序设计法。  将一些常用的数据结构（比如链表
C++常用标准模板库（STL）
mysterious_z的博客
03-11 1092
C++常用标准模板库 1.vector（向量，即动态数组） 时间复杂度分析：数组后面插入元素和删除尾部元素O(1)，头部或者中间插入删除依旧是O(n) 优点：可以动态的随着元素的增加和减少改变数组的长度，使用起来与普通数组区别不大 操作方法： 头文件 #include 定义与初始化操作 vector<int>v;//创建一个数组v,类型为int vector<int>v(v1);//创建一个数组v，类型为int，并且初始化为v1 vector<int>v(v1.b
C++类模板与STL编程
最新发布
05-19
C++类模板是一种通用的类定义，可以用来定义任意类型的类。STL（Standard Template Library）是C++...总之，C++类模板和STL是C++中非常重要的特性，可以方便地实现通用的数据结构和算法，提高程序的可读性和可维护性。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值