STL模板

其他 2019-01-19 16:00:38 阅读次数: 0
版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/adzn1/article/details/80260088

STL: S标准 T：模板 L：库

模板的报错不准确

学习内容：

  • 1、什么是模板？
  • 2、模板的原理？
  • 3、模板函数、模板类
  • 4、非类型模板参数
  • 5、特化–类型萃取
  • 6、模板的分离编译

一、泛型编程

  • 模板：模板是泛型编程的基础。所谓泛型编程就是编写与类型无关的逻辑代码，是一种复用方式。
  • 分类：模板函数和模板类。

二、模板函数

1）- 模板函数
假设现在要实现一个比较两个数是否相等的重载函数。

#include<iostream>
#include<stdlib.h>
#include<stdio.h>
using namespace std;
template<class T>
void Swap(T* x1, T* x2)
{
    T x = *x1;
    *x1 = *x2;
    *x2 = x;
}
int main()
{
    int a = 1, b = 2;
    Swap(&a, &b);

    int *p1 = &a;
    int *p2 = &b;
    Swap(&p1, &p2);

    char c1 = 1, c2 = 2;
    Swap(&c1, &c2);

    system("pause");
    return 0;
}

第一组交换前：
这里写图片描述
第一组交换后：
这里写图片描述
第二组交换前：
这里写图片描述
第二组交换后：
这里写图片描述

void Swap(T* *x1, T** x2)
{
    T x = **x1;
    **x1 = **x2;
    **x2 = x;
}

第三组交换前：
这里写图片描述

第三组交换后：
这里写图片描述

查看反汇编：
这里写图片描述

结论：

函数模板格式：
 template<class 形参名1，class形参名2，class形参名n>
 返回类型 函数名（参数列表）
 {...}
  • 模板形参的定义既可用class，也可使用typename,含义是相同的。

  • 不同的函数推演出不同的模板类型，底层调用的是三个不同的函数类型。

  • 模板函数只有被推演出来是什么类型才参与编译，否则不参与编译。没有被推演出来的话，它只检查函数的外壳即函数名哪一行，函数内部不检查。
    “`

string 的底层汇编是basic_string

int 的底层汇编是int

这里写图片描述

2）模板参数匹配及显示实例化

由于传不同类型的参数会导致推演出的函数类型不匹配进而导致编译器报错，因此可以指定所传参数推演出的类型。如下图：

这里写图片描述

3）重载函数模块

本质是模板推演出的函数构成重载

template<typename T>
bool IsEqual(const T& left, const T& right)
{
    return left == right;
}
template <typename T1,class T2>
bool IsEqual(const T1& left, const T2& right)
{
    return left == right;
}
bool IsEqual(const int& left, const int& right)
{
    return left == right;
}
int main()
{
    /*string s1("s1");
    string s2("s2");*/
    cout << IsEqual(1, 2) << endl;
    cout << IsEqual(1.2,1) << endl;
    cout << IsEqual<double>(1.2, 1) << endl;
    cout << IsEqual<int>(1.2, 1) << endl;
    system("pause");
    return 0；
}

它们构成重载，但是1、3两个编译器该调谁呢？

这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述
这里写图片描述

总结：

  • 编译器调用如果有现成的就不会去推演，没有现成的就会去推演
  • <>指定只能是模板函数

模板类：

类模板的格式

template<class 形参名1, class 形参名2, ...class 形参名n>   
class 类名 { ... };

这里写图片描述
模板类实现动态顺序表：
https://mp.csdn.net/mdeditor/80299402

模板参数–实现容器适配器

template <typename T>
 class SeqList 
 { 
   private :   
   int _size ;   
   int _capacity ;    
   T* _data ;
  };
// template <class T, class Container>
   template <class T, class Container = SeqList<T > //缺省参数 
   class Stack
    {
    public :    
    void Push (const T& x );     
    void Pop ();     
    const T & Top();     
    bool Empty ();
    private :    
    Container _con ;
    };
    void Test () 
    {     
    Stack<int > s1;     
    Stack<int , SeqList< int>> s2 ;
    }

模板的模板参数–容器适配器

两种形式：
1）
这里写图片描述
2）
这里写图片描述

非类型的类模板参数

template<typename T,size_t MAX_SIZE=10>//带缺省模板参数
class SeqList
{
public:
    SeqList();
private:
    T_array[MAX_SIZE];
    int _size;
};
template<typename T,size_t MAX_SIZE>
SeqList<T, MAX_SIZE>::SeqList()
        :_size(0)
{}
void Test()
{
    SeqList<int>s1;
    SeqList<int, 20>s2;
}

图解：
这里写图片描述
扩展 面试题：
不要使用循环 */，实现1+2+3+…+n
1、实现 不要求
2、实现哦 o（1）–非类型模板参数

类型萃取

 cout<<typeid(T).name()<<endl;

类型萃取：RTTI
1、T->int char double… 内置类型 memcpy
2、T->string… 自定义类型类型 for+operator=

RTTI:程序能够使用基类的指针或引用来检查这些指针或引用所指的对象的实际派生类型。

模版的特化

代码：
1、特化之前：

template<class T>
class SeqList
{
public:
    void Expand()
    {
        cout << "for+operator=" << endl;
    }
};

int main()
{
    SeqList<int> s1;
    s1.Expand();
    SeqList<string> s2;
    s2.Expand();
    system("pause");
    return 0;
}

运行结果：
这里写图片描述分析：
调用的全是for+operator=
2、特化：
代码：

template<>
class SeqList<int>
{
public:
    void Expand()
    {
        cout << "memcpy" << endl;
    }
};

结果：
这里写图片描述
分析：
调用了两种方式。
结论：2称之为1的特化

全特化

代码：

template < typename T1,typename T2>
class Data
{
public:
    Data()
    {
        cout << "<T1,T2>" << endl;
    }
private:
    T1 _d1;
    T2 _d2;
};
template<>
class  Data<int,int>
{
public:
    Data()
    {
        cout << "<int,int>" << endl;
    }
private:
    int _d1;
    int _d2;
};

int main()
{
    Data<int, int>d1;
    Data<int, char>d2;
    system("pause");
    return 0;
}

结果：
这里写图片描述
结论：

  • 有对应的类型则调对应的类型，
  • 无对应的模型则调模版参数类型进行推演。

偏特化：
代码;

template<class T>
class SeqList
{
public:
    void Expand()
    {
        cout << "for+operator=" << endl;
    }
};

template < typename T1,typename T2>
class Data
{
public:
    Data()
    {
        cout << "<T1,T2>" << endl;
    }
private:
    //T1 _d1;
    //T2 _d2;
};
//全特化
template<>
class  Data<int,int>
{
public:
    Data()
    {
        cout << "<int,int>" << endl;
    }
private:
    int _d1;
    int _d2;
};
//偏特化
template<class T1>
class  Data<T1, int>
{
public:
    Data()
    {
        cout << "<T1,int>" << endl;
    }
private:
    int _d1;
    int _d2;
};
//偏特化(指针类型）
template<typename T1,typename T2>
class  Data<T1*,T2*>
{
public:
    Data()
    {
        cout << "<T1*,T2*>" << endl;
    }
private:

};
//偏特化(引用类型）
template<typename T1, typename T2>
class  Data<T1&,T2&>
{
public:
    Data()
    {
        cout << "<T1&,T2&>" << endl;
    }
private:

};
////偏特化(引用类型）
//template<typename T1, typename T2>
//class  Data<T1&, T2&>
//{
//public:
//  Data()
//  {
//      cout << "<T1&,T2&>" << endl;
//  }
//private:
//
//};



int main()
{
    Data<int, int>d1;
    Data<int, char>d2;
    Data<char, int>d3;
    Data<int*, int*>d4;
    Data<char&, int&>d5;
    Data<char*, int&>d6;
    system("pause");
    return 0;
}

这里写图片描述

POD类型萃取：

#include<iostream>
using namespace std;
#include<stdio.h>
#include<stdlib.h>
struct __TrueType
{};
struct __FalseType
{};
template < class T>
struct TypeTraits
{
    typedef __FalseType IsPodType;
};
template<>
struct TypeTraits<int>
{
    typedef __TrueType IsPodType;
};
template<class T>
T* __TypeCopy(const T* src, T* dst, size_t n,__TrueType)
{
    cout << "memcpy" << endl;
    return (T*)memcpy(dst, src, sizeof(T)*n);
}
template<class T>
T* __TypeCopy(const T* src, T* dst, size_t n,__FalseType)
{
    for (size_t i = 0; i < n; i++)
    {
        dst[i] = src[i];
    }
    cout << "for+operator=" << endl;
    return dst;
}
template<class T>
T* TypeCopy(const T* src, T* dst, size_t n)
{
    return __TypeCopy(src, dst, n,TypeTraits<T>::IsPodType());
}

void TestCopy()
{
    int srcint[3] = { 1, 2, 3 };
    int dstint[3] = { 0 };

    string srcstring[3] = { "11", "22", "33" };
    string dststring[3];

    TypeCopy(srcint, dstint, 3);
    TypeCopy(srcstring, dststring, 3);
}
int main()
{
    TestCopy();
    system("pause");
    return 0;
}

运行截图：
int 型：

这里写图片描述
string 型：
这里写图片描述

图解：
这里写图片描述
总结：
1、偏特化并不仅仅是指特殊部分参数，而是针对模板参数更进一步的条件限制所设计出来的一个特化版本
2、模板的全特化和偏特化都是在已定义的模板基础之上，不能单独存在。

模板的分离编译：

1、模板不支持分离编译，why？

分离编译不会模板实例化

2、怎样解决？

1）显示实例化，最好指定模板类型（因为有的模板必须指定类型）。
2）最好的方式是把声明和定义放一个头文件里（类里面定义太大了）。

模版总结：

优点：

  • 1、模板复用了代码，节省资源，更快的迭代开发，c++的标准模版库（STL)因此而产生
  • 2、增强了代码的灵活性。

缺点：

  • 1、模版让代码变得凌乱复杂，不易维护，编译代码时间变长。

  • 2、出现模板编译错误时，错误信息非常凌乱，不易定位错误。

猜你喜欢

转载自blog.csdn.net/adzn1/article/details/80260088
今日推荐
Apache Doris 2.0.10 版本正式发布！
开源日报 | 大模型开战；大模型独角兽被曝卖身；周鸿祎建议谷歌开源所有产品；最大开源AI社区提供1000万美元共享GPU
开源日报 | Chrome内置Gemini的意义不在于Gemini；中国AI追随之路的五大误区；ECharts创始人“下海”养鱼；谷歌I/O开发者大会什么都有，只是没有惊喜
微软回应中国区AI团队“打包赴美”传闻
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
周排行
阿里云短信服务平台注册
Windows下的字符串处理(1)
sqoop: mysql导入数据到hdfs, hive, hbase
commons.lang中常用的工具类
离线安装PostgreSQL11.6
使用PyTorch简单实现卷积神经网络模型
一文彻底搞定谱聚类
一道面试题引发的血案
One Chat for Mac(聊天工具)
TCP/IP的底层队列是如何实现的？
每日归档
更多
2024-05-17(34)
2024-05-16(6)
2024-05-15(24)
2024-05-14(0)
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022