STL类模板入门

最新推荐文章于 2024-06-30 20:23:11 发布
最新推荐文章于 2024-06-30 20:23:11 发布
阅读量498 收藏
点赞数 1
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40743639/article/details/127723153
版权

Unit04 类模板

01 类模板的声明

  • 形式：template<class 类型形参1, …> class 类模板名 { … };

    例如：

    template<class A, class B>
class CMath
{
public:
    A m_a;
    B func() { ... };
};

  • 如果在类模板外实现成员函数

    template<class 类型形参1, ...>
返回值类型 类模板名<类型形参1, ...>::函数名(调用形参1, ...)
{
    函数体实现;
}

    例如：

    template<class A, class B>
B Cmath<A, B>::func()
{
    ....;
}

  • 实例：

    #include <iostream>
using namespace std;
//类模板
template<class T>
class CMath
{
public:
    CMath(T const& t1, T const& t2) : m_t1(t1), m_t2(t2) {}
    // T add();
    //声明实现写一起
    T add() {
        return m_t1 + m_t2;
    }
private:
    T m_t1;
    T m_t2;
};
//声明实现分开写
// template<class T>
// T CMath<T>::add()
// {
//     return m_t1 + m_t2;
// }

int main()
{
    return 0;
}

02 类模板的使用

  • 使用类模板必须对类模板进行实例化（产生真正的类）

    类模板本身并不代表一个确定的类型（即不能用与定义对象），只有通过类型实参实例化成真正的类后才具备类的语义（即可以定义对象）。

    例如：CMath<int, double> math;

#include <iostream>
using namespace std;
//类模板
template<class T>
class CMath
{
public:
    CMath(T const& t1, T const& t2) : m_t1(t1), m_t2(t2) {}
    // T add();
    //声明实现写一起
    T add() {
        return m_t1 + m_t2;
    }
private:
    T m_t1;
    T m_t2;
};
//声明实现分开写
// template<class T>
// T CMath<T>::add()
// {
//     return m_t1 + m_t2;
// }

int main()
{
    int nx = 10, ny = 20;
    CMath<int> m1(nx, ny);
    cout << m1.add() << endl;
    double dx = 12.3, dy = 45.6;
    CMath<double> m2(dx, dy);
    cout << m2.add() << endl;
    string sx = "hello", sy = " world";
    CMath<string> m3(sx, sy);
    cout << m3.add() << endl;
    return 0;
}

  • 类模板被实例化时类模板中的成员函数并没有实例化，成员函数只有在被调用时才会被实例化（即产生真正成员函数）注意：成员虚函数除外。

  • 某些类型虽然并没有提供类模板所需要的全部功能但照样可以实例化类模板，只要不调用那些未提供功能的成员函数即可。

03 类模板的静态成员

  • 类模板中的静态成员即不是每个对象拥有一份。
  • 也不是类模板拥有一份。
  • 而应该是由类模板实例化出的每一个真正的类个有一份。
  • 且为该类实例化类定义的所有对象共享。
#include <iostream>
using namespace std;

template<class T>
class A
{
public:
    static void print() {
        cout << "&m_i:" << &m_i;
        cout << ", &m_t:" << &m_t << endl;
    }
    static int m_i;
    static T m_t;
};
template<class T>int A<T>::m_i;   // = 0;
template<class T>T A<T>::m_t;     //= ??

int main()
{
    A<int> x, y, z;
    x.print();
    y.print();
    z.print();
    A<int>::print();

    cout << endl;

    A<double> m, n, t;
    m.print();
    n.print();
    t.print();
    A<double>::print();

    return 0;
}

04 类模板的递归实例化

  • 可以使用任何类型来实例化类模板。
  • 由类模板实例化产生的类也可以用来实例化类模板自身，这种做法称之为类模板的递归实例化。
  • 通过这种方法可以构建空间上具有递归特性的数据结构（例如：多维数组）。
#include <iostream>
using namespace std;

template<class T>
class Array
{
public:
    T& operator[](size_t i) {
        return m_arr[i];
    }
private:
    T m_arr[10];
};

int main()
{
    Array< Array<int> > m;
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            m[i][j] = i + j;
        }
    }
    for (int i = 0; i < 10; i++) {
        for (int j = 0; j < 10; j++) {
            cout << m[i][j] << '\t';
        }
        cout << endl;
    }

    return 0;
}

Unit05 类模板扩展

01 全局特化

  • 全类特化：特化一个类模板可以特化该类模板所有的成员函数，相当于重新写了一个针对某种特定数据类型的具体类

    声明形式：template<>class 类模板名<类型参数1, ...> {...}

    例如：template<>class CMath<char*> {...}

  • 成员特化：类模板特化除了可以对整个类进行特化以外，可以只针对某部分成员函数进行特化。

    声明形式：template<>返回值类型 类模板名<类型参数1, ...>::成员函数名(调用参数1, ...) {...}

    例如：template<> char* const CMath<char* const>::add(...) {...}

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

template<class T>
class CMath
{
public:
    CMath(const T& t1, const T& t2) : m_t1(t1), m_t2(t2) {}
    T add() {
        return m_t1 + m_t2;
    }
private:
    T m_t1;
    T m_t2;
};

//成员特化
template<>
char* const CMath<char* const>::add() {
    return strcat(m_t1, m_t2);
}

/*
//全类特化
template<>
class CMath<char* const>
{
public:
    CMath<char* const>(char* const& t1, char* const& t2) : m_t1(t1), m_t2(t2) {}
    char* const add() {
        return strcat(m_t1, m_t2);
    }
private:
    char* const m_t1;
    char* const m_t2;
};
*/

int main()
{
    char cx[256] = "hello", cy[256] = " world";
    CMath<char* const> m(cx, cy);
    cout << m.add() << endl;

    return 0;
}

何时使用：当一个模板类中的某些成员函数中的操作针对某些数据类型无法执行时，使用全局特化来特殊处理这种数据类型实例化出来的具体类。其中全局特化的工作量较大，成员特化可以只针对那些无法执行的成员函数进行重写。

02 局部特化

  • 类模板的局部特化，除非必要否则尽量不要特化，因为特化版本过多容易引发编译器匹配歧义。
#include <iostream>
using namespace std;

template<class T, class D>class CMath {
public:
    static void foo() {
        cout << "1:CMath<T, D>::foo" << endl;
    }
};

//局部特化1
template<class T>class CMath<T, short> {
public:
    static void foo() {
        cout << "2:CMath<T, short>::foo" << endl;
    }
};

//局部特化2
template<class T>class CMath<T, T> {
public:
    static void foo() {
        cout << "3:CMath<T, T>::foo" << endl;
    }
};

//局部特化3
template<class T, class D>class CMath<T*, D*> {
public:
    static void foo() {
        cout << "4:CMath<T*, D*>::foo" << endl;
    }
};

int main()
{
    CMath<int, double>::foo();   //1
    CMath<int, short>::foo();    //2
    //CMath<short, short>::foo();  //匹配歧义
    CMath<int*, double*>::foo(); //1
    CMath<int*, int*>::foo();    //匹配歧义
    return 0;
}

03 类型形参的缺省

  • 类模板的类型形参可以带缺省值。

    实例化类模板时，如果提供了类型实参则用所提供的类型实参来实例化类模板，如果没有提供类型实参则用相应的类型形参的缺省类型来实例化类模板。

  • 如果类模板的某个类型形参带有缺省值，那么它后面的类型形参都必须带缺省值。

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

template<class T=short, class D=int>class CMath {
public:
    void print() {
        cout << "m_t:" << typeid(m_t).name() << ", "
        << "m_d:" << typeid(m_d).name() << endl;
    }
private:
    T m_t;
    D m_d;
};

int main()
{
    CMath<float, double> m;
    m.print();
    CMath<> m2;
    m2.print();

    return 0;
}

04 数值形的模板参数

  • 类模板的模板形参并不限于类型参数，不同数值也可以作为模板的参数。
#include <iostream>
using namespace std;

template<class T=double, size_t S=15>class Array {
public:
    T& operator[](size_t i) {
        return m_arr[i];
    }
    size_t size() {
        return S;
    }
private:
    T m_arr[S];
};

int main()
{
    Array<int, 20> a;
    for (int i = 0; i < a.size(); i++) {
        a[i] = i + 1;
    }
    for (int i = 0; i < a.size(); i++) {
        cout << a[i] << " ";
    }
    cout << endl;

    return 0;
}

05 模板技巧

01 模板型成员变量

成员变量，但其类型是由一个类模板实例化的未知类，那么它才可以称之为模板型成员变量

例如：

template<class T>class Array {...};
template<class D>class Sum {
public:
    Array<D> m_s;    //模板型成员变量
};

#include <iostream>
using namespace std;

template<class T>class Array {
public:
    T& operator[](size_t i) {
        return m_arr[i];
    }
private:
    T m_arr[10];
};
template<class D>class Sum {  //求和器
public:
    Sum(Array<D>& s) : m_s(s) {}
    D add() {
        D d = 0;
        for (int i = 0; i < 10; i++) {
            d += m_s[i];
        }
        return d;
    }
private:
    Array<D> m_s;    //模板型成员变量
};

int main()
{
    Array<int> a;
    for (int i = 0; i < 10; i++) {
        a[i] = i + 1;
    }
    Sum<int> s(a);
    cout << s.add() << endl;

    return 0;
}
02 模板型成员函数

类模板的成员函数模板

例如：

template<class T>class CMath {
public:
    template<class D>void foo() {...}  //成员函数模板
};

如果在类外实现：

template<class T>template<class D>void CMath<T>::foo() {...}

#include <iostream>
using namespace std;

template<class T>class CMath {
public:
    template<class D>void foo();
    // template<class D>void foo() {    //成员 函数模板
    //     cout << "CMath<T>::foo<D>()" << endl;
    // }
};

template<class T>
template<class D>void CMath<T>::foo()
{
    cout << "CMath<T>::foo<D>()" << endl;
}

int main()
{
    CMath<int> m;
    m.foo<double>();

    return 0;
}
03 模板型成员类型

类模板中嵌套的类模板

例如：

template<class X>class A {
public:
	template<class Y>class B {...};    //模板型成员类型
};

#include <iostream>
using namespace std;

template<class X>class A {
public:
    template<class Y>class B {
    public:
        template<class Z>class C;
    };
};

template<class X>
template<class Y>
template<class Z>class A<X>::B<Y>::C {
public:
    template<class T>void foo() {
        cout << "foo()" << endl;
    }
};

int main()
{
    A<int>::B<double>::C<float> c;
    c.foo<string>();

    return 0;
}
04 模板型模板参数

类模板的模板形参也可以是类模板，可以有缺省值

例如：

template<class T>class Array {...};
template< template<class D>class C=Array >class Sum {
    ...
};

#include <iostream>
using namespace std;
template<class T>class Array {
public:
    T& operator[](size_t i) {
        return m_arr[i];
    }
private:
    T m_arr[10];
};
template<class D, template<class M>class C>class Sum {
public:
    Sum(C<D>& s) : m_s(s) {}
    D add() {
        D d = 0;
        for (int i = 0; i < 10; i++) {
            d += m_s[i];
        }
        return d;
    }
private:
    C<D> m_s;
};

int main()
{
    Array<int> a;
    for (int i = 0; i < 10; i++) {
        a[i] = i + 1;
    }
    Sum<int, Array> s(a);
    cout << s.add() << endl;

    return 0;
}

Unit06 模板典型错误

01 嵌套依赖

  • 问题：

    由于模板要经过两次编译，在第一次编译模板的代码时，类型形参的具体类型尚不明确，编译器将把类型形参的嵌套类型理解为某个未知类型的静态成员变量，因此编译器看到使用这样的标识符声明变量时会报告错误，这就叫嵌套依赖。

  • 解决方法：

    在类型形参的前面增加一个typename标识符，意在告诉编译器其后时一个类模板的嵌套使用。

#include <iostream>
using namespace std;
class A {
public:
    class B {
    public:
        void foo() {
            cout << "A::B::foo()" << endl;
        }
    };
};
template<class T>void Func() {
    typename T::B b;    //嵌套依赖
    b.foo();
}

int main()
{
    Func<A>();
    return 0;
}

02 依赖模板参数访问成员函数模板

  • 问题：

    利用未知类定义的对象来访问成员函数模板时，编译器在第一次编译时无法解析成员函数模板的类型参数列表的 <> 而报告编译错误。

  • 解决方法：

    在成员函数模板之前增加template关键字，意在告诉编译器其后是一个函数模板实例，编译器就可以正确理解 <> 了。

#include <iostream>
using namespace std;
class A {
public:
    template<class T>void foo() {
        cout << "A::foo()" << endl;
    }
};
template<class D>void Func() {
    D d;
    d.template foo<int>();    //依赖模板参数访问成员函数模板
}

int main()
{
    Func<A>();
    return 0;
}

03 子模板访问基模板

  • 问题：

    在子类模板中访问基类模板的成员，编译器第一次编译时只在子类模板和全局域中搜索使用的标识符号，不会到基类模板中搜索。

  • 解决方法：

    在子类模板中可以通过使用作用域限定符或显示使用 this 指针。

#include <iostream>
using namespace std;
template<class T>class Base {
public:
    int m_i;
    void foo() {
        cout << "Base<T>::foo()" << endl;
    }
};

template<class T, class D>class Derived : public Base<T> {
public:
    void bar() {
        Base<T>::m_i = 100;
        Base<T>::foo();
        // this->m_i = 100;
        // this->foo();
    }
};

int main()
{
    Derived<int, double> d;
    d.foo();
    return 0;
}

04 零值初始化

  • 问题：

    基本类型不存在缺省构造函数，未被初始化的局部变量都具有一个不确定的值（int a;//值不确定）

    类类型由于存在缺省构造函数，在未被初始化的情况下可以有一个确定的缺省初始化状态。（Integer a;//值确定）

    基于以上两点，就会在模板实现中产生不一致的语法语义。

  • 解决方法：

    如果希望模板中，所有类型参数的变量，无论是类类型还是基本类型都以缺省方式获得初始化，就必须对其进行显示缺省构造 T()。

#include <iostream>
using namespace std;

class Integer {
public:
    Integer() : m_i(0) {}
private:
    int m_i;
    friend ostream& operator<<(ostream& os, const Integer& that);
};
ostream& operator<<(ostream& os, const Integer& that) {
    return os << that.m_i;
}

template<class T>void Func() {
    T t = T();    //Integer() / int()
    cout << "t=" << t << endl;
}

int main()
{
    Func<int>();
    Func<Integer>();
    return 0;
}

05 类模板中的成员虚函数

  • 类模板中的普通成员函数可以是虚函数

    即可以为类定义成员虚函数，和普通类的成员虚函数一样，类模板的成员虚函数也可以表现出多态性。

  • 类模板中的成员函数模板不可以是虚函数

    根据成员虚函数的多态机制，需要一个虚函数表（表中保存成员虚函数的入口地址），而这个表是编译器在实例化类模板时就产生，类的成员函数模板的实例化（即产生真正的函数实体）需要编译器处理完调用后才会完成，这是才出现成员虚函数的地址。

  • 总结：

    成员函数模板的延迟编译阻碍了虚函数表的静态构建。

#include <iostream>
using namespace std;

template<class T>class Base {
public:
    virtual void foo() {
        cout << "Base<T>::foo()" << endl;
    }
    template<class M>void bar() {

    }
};

template<class T, class D>class Derived : public Base<T> {
public:
    virtual void foo() {
        cout << "Derived<T, D>::foo()" << endl;
    }
};

int main()
{
    Derived<int, double> d;
    Base<int>* pBase = &d;
    pBase->foo();
    pBase->bar<int>();
    return 0;
}
一个小黑酱
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
STL模板类
yleave的博客
06-23 2157
文章目录一、algorithm头文件1.count() ：统计给定值或字符的个数，例如字符串中统计某个字符的个数。2.find() : 返回第一个值等价于给定值的元素，记住返回的是指针或游标迭代子，而不是索引。3.search() : 在范围A中查找第一个与范围B等价的子范围的位置。例如查找子字符串功能。4.swap() : 交换两个对象的值，用处很广，无论交换两个整型，还是两个字符数组，非常实用...
STL模板
Gank_Wind的博客
07-21 245
前言 背就完了，奥里给！ 什么是STL STL(Standard Template Library),意为标准模板库，是c++提供的一系列"容器",这里只说其中的vector,priority_queue,map,pair,set五种(实际为四种，因为pair在map的结构里),其中,除了setsetset外都有下标访问和迭代器访问两种方法 Vectoe 又名变长数组，长度没有固定约束，随着需要的值而变化，在要用到多个数组或结构体时可 以用到. 需要用到头文件#include< vector&g
STL(标准模板库)
热门推荐
m0_60274660的博客
11-29 2万+
概念： STL：标准模板库，是C++标准库的重要组成部分 由概念便可以知道，STL中的所有数据结构都是以模板的方式创建的 LIST--container： list节点： list节点是一个双向指针，实质是一个模板结构体 template<class T> struct _list_node { typedef void* void_pointer; void_pointer prev;//previous void_pointer next;
面向对象和C++基础—标准模板库(STL)篇
Voltline的博客
06-10 988
面向对象和C++基础—标准模板库(STL)篇
【STL】模板概念+STL介绍
m0_52309496的博客
11-26 647
STL学习笔记01
标准模板库STL
qq_37346140的博客
01-04 912
向量（vector）：类似数组（内部是线性存储）支持下标访问，在尾部添加和删除元素效率高，中间执行添加删除操作可以，但效率很低。双端队列( deque ) : 支持下标访问（头尾两端都可添加/删除操作）。列表（list）：在任何位置添加和删除操作都很方便，不支持下标访问。堆栈（stack）：支持在一端存储和提取元素。队列（queue）：支持从前端提取，后端压入元素。优先队列（priority_queue）：类似队列，但所提取的是具有最高优先级的元素（默认大者优先）。映射（map）
C++STL 标准模板库
qq_70799748的博客
03-30 395
算法：用来处理群集内的元素，它们可以出于不同的，䣌而搜索，排序，修改，使用那些元素。是一种应用在容器上以各种方法处理其内存的行为或功能，如sort(排序)，copy(拷贝)...,算法由模板函数体现，这些函数不是容器类的成员函数，是独立的函数，它们可以用于STL容器，也可以用于普通的C++函数。：用来管理某类对象的集合，容纳特定数据结构对象的集合，STL容器是将最常用的一些数据结构实现出来，包含了许多数据结构，如：vector，queue,stack...string也可以看作是一个容器。
STL实用入门教程
06-25
STL，全称为Standard Template Library（标准模板库），是C++编程语言中不可或缺的一部分，它为程序员提供了高效且灵活的数据结构和算法。本教程由阙海忠主讲，旨在帮助初学者快速掌握STL的基本概念和用法。通过一...
STL模板类基础Demo
08-02
几乎已经把STL中所有容器的基础使用方式敲了一遍。...这应当是STL入门的基础案例，希望大家能够自己手动敲一遍。 这也可以作为STL用法字典工具来使用。Demo也是自己手敲一遍的，对其认识也是很深刻。
STL模板入门
08-31
介绍泛型编程STL的基础
C++ STL编程轻松入门
04-13
模板可以创建泛型函数和泛型类，使得STL能够处理不同类型的数据。此外，STL的实现通常利用C++的模板元编程（Template Metaprogramming）技术，这是一种在编译时进行计算和代码生成的技术，进一步提高了效率。 STL的...
STL标准模板库
09-19
学习STL的好资料 本文以List容器为例子，介绍了STL的基本内容，从容器到迭代器，再到普通函数，而且例子丰富，通俗易懂。不失为STL的入门文章，新手不容错过!
【C++】标准模板库（STL）
weixin_53235104的博客
05-06 5133
标准模板库 STL（Standard Template Library），是 C++ 标准库的一部分，不需要单独安装，只需要 #include 头文件。STL 的一个重要特点是数据结构和算法的分离。尽管这是个简单的概念，但这种分离确实使得STL 变得非常通用。例如，由于 STL 的 sort() 函数是完全通用的，你可以用它来操作几乎任何数据集合，包括链表、容器和数组；STL 的另一个重要特性是它不是面向对象的。STL 主要依赖于模板而不是封装、继承和虚函数（多态性）—— OOP的三个要素。
C++进阶语法——STL 标准模板库（下）（Standard Template Library）【C++深度学习部署（七）】
qq_23022733的博客
11-01 731
容器类型::iterator 变量名称。而不是使用C++原生数组。
自己动手实现简易STL
weixin_44344205的博客
04-15 1912
自己动手实现简易STLSTL六个组件迭代器 & 算法容器，迭代器部分适配器仿函数额外的工作小结 之前学习C++看侯老师的书的时候实现了一下STL的基本组件，包括了6个组件,allocator, iterator, container, trait, functor, algorithm的组件，也是终于搞清楚了6个组件之间的相互关联，但是这么写着(CTRL C + V)有点无聊，于是做了一些数据结构的可视化，当时本来是想加更多的功能来着，比如高亮最近改变或者查找的某个数据。 STL六个组件 比较难理解
【C++】——模板初阶 | STL简介
weixin_73551991的博客
02-23 1512
STL是 C++ 标准模板库（Standard Template Library）的缩写。
STL标准模板库（一）
Ryan_hsMax的博客
03-21 1290
这下子我们一口气将STL中常用的一大部分讲完了，请先缓一缓，自己去写写代码，多多记忆，这样才能将收益最大化。等下一篇，我们将剩余的stack，queue,priority_queue也一次性讲完！最后，本篇文章是作者自己学习过后自行总结而成，可能会有些缺漏，我就在此，请看官们赐教！！！！！！！
【C++】————string基础用法及部分函数底层实现
最新发布
bhbcdxb123的博客
06-30 624
本文主要介绍STL容器之一 ---- string，在学习C++的过程中，我们要将C++视为一个语言联邦（摘录于Effective C++ 条款一）。如何理解这句话呢，我们学习C++，可将其分为四个板块；分别为C、Object-Oriented C++（面向对象的C++）、Template C++（模板）、STL。本文就介绍STL中的string；1.一个冷知识：屏蔽力是一个人最顶级的能力，任何消耗你的人和事，多看一眼都是你的不对。2.你不用变得很外向，内向挺好的，但需要你发言的时候，一定要勇敢。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值