c++类模板

已于 2023-09-14 22:06:25 修改
阅读量1.3k 收藏 4
点赞数 1
分类专栏： C++ 学习 文章标签： c++ 开发语言
于 2023-09-02 22:22:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012011912/article/details/132630312
版权

一、类模板基本概念

在C++中，模板类是一种用于创建通用数据结构或算法的强大工具。模板类允许您编写一次代码，然后在不同数据类型上重复使用它，以提高代码的可重用性和灵活性。

模板类允许您定义一种通用的类模板，其中某些成员或函数可以根据不同数据类型进行参数化。它们使用template关键字定义

template <class T>
class 类模板名
{
类的定义;
};

函数模板建议用 typename 描述通用数据类型，类模板建议用 class。

1.1 类模板举例

template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;
    
    MyClass() {}
    
    //通用类型用于成员函数的参数
    MyClass(T1 a, T2 b) : a_(a), b_(b) {
    }
    
    //通用类型用于成员函数返回值
    T1 fun() {
        T1 a = 2; //通用类型用于成员函数代码中
        return a;
    }
};

int main() {
    MyClass<int, double> myClass;//用模板类AA创建对象myClass，其中的数据类型只能显示设置，不能隐形自动推导
    myClass.a_=30;
    myClass.b_=32.9;
    cout<<myClass.fun();//2
}

注意：

  1. 在创建对象的时候，必须指明具体的数据类型。

    MyClass<int, double> myClass;//用模板类AA创建对象myClass，其中的数据类型必须指明，不能隐形自动推导，

  2. 使用类模板时，数据类型必须适应类模板中的代码。

    template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {}

    //通用类型用于成员函数的参数
    MyClass(T1 a, T2 b) : a_(a), b_(b) {
    }

    //通用类型用于成员函数返回值
    T1 fun() {
    	//假如T1的类型是string字符串，那么这句话就是错的
        T1 a = 2; //通用类型用于成员函数代码中
        return a;
    }
};

  3. 类模板可以为通用数据类型指定缺省的数据类型(C++11 标准的函数模板也可以，但是对函数模板意义不大)。

    template<class T1, class T2=double>//如果第二个缺失，默认使用double
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {}

    //通用类型用于成员函数的参数
    MyClass(T1 a, T2 b) : a_(a), b_(b) {
    }

    //通用类型用于成员函数返回值
    T1 fun() {
        T1 a = 2; //通用类型用于成员函数代码中
        return a;
    }
};

int main() {
    MyClass<int> myClass;//缺少第二个参数，默认使用double
    myClass.a_=30;
    myClass.b_=32.9;
    cout<<myClass.fun();//2
}

  4. 模板类的成员函数可以在类外实现。

    template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {}

    //通用类型用于成员函数的参数
    MyClass(T1 a, T2 b) : a_(a), b_(b) {
    }

    //通用类型用于成员函数返回值
    T1 fun();

};
//在类外定义，但是类外不支持数据类型缺省，因为不同的编译器可能不支持
template<class T1, class T2>
T1 MyClass<T1,T2>::fun() {
    T1 a = 2; //通用类型用于成员函数代码中
    return a;
}


int main() {
    MyClass<int,double> myClass;//用模板类AA创建对象myClass，其中的数据类型只能显示设置，不能隐形自动推导
    myClass.a_=30;
    myClass.b_=32.9;
    cout<<myClass.fun();//2
}

  5. 可以用 new 创建模板类对象。

    template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {}

    //通用类型用于成员函数的参数
    MyClass(T1 a, T2 b) : a_(a), b_(b) {
    }

    //通用类型用于成员函数返回值
    T1 fun() {
        T1 a = 2; //通用类型用于成员函数代码中
        return a;
    }
};


int main() {
    MyClass<int,double> *myClass = new MyClass<int,double>;
    MyClass<int,double> *myClass1 = new MyClass<int,double>(3,1.4);
}

  6. 在程序中，模板类的成员函数使用了才会创建。

    template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {
        a_.ccc;//这行会报错
    }
};

int main() {
    MyClass<int,int> *m;//只声明了指针，但未创建类对象，不会调用构造函数，所以不会报错
}

    template<class T1, class T2>
class MyClass {
public:
    T1 a_;//通用类型用于成员变量
    T2 b_;

    MyClass() {
    }

    void fun(){
        a_.da2342342();
    }
};


int main() {
    MyClass<int,int> *m=new MyClass<int,int>;//也不会报错，因为每调用fun函数
}

二、创建模板类的方法

  1. 先写一个普通类，用具体的数据类型
  2. 调试普通类
  3. 把模板类改为模板类

三、模板类示例——栈

  1. 普通类实现：以int类型为例

    class Stack{
private:
    int *items;//栈数组
    int stacksize;//栈大小
    int top;//栈顶指针
public:
    //构造函数
    Stack(int size):stacksize(size),top(0){
        items = new int[size];
    }
    //析构函数
    ~Stack(){
        delete []items;//释放内存
        items=nullptr;
    }
    //判断是否为空
    bool isEmpty() const{
        return top == 0;
    }
    //判断是否已满
    bool isFull() const{
        return top == stacksize;
    }
    //入栈
    bool push(const int& item){
        if(isFull()){
            return false;
        }
        items[top++] = item;
        return true;
    }
    //出栈
    bool pop(int &item){
        if(isEmpty()){
            return false;
        }
        item = items[--top];
        return true;
    }
};

int main(){
    Stack stack(10);
    stack.push(1);
    stack.push(2);
    stack.push(3);
    int popitem;
    while (!stack.isEmpty()){
        stack.pop(popitem);
        cout << popitem << endl;
    }
}

  2. 使用typedef来自定义元素类型,实现类似于类模板功能

    typedef int DataType;//定义数据类型

class Stack{
private:
    DataType *items;//栈数组
    int stacksize;//栈大小
    int top;//栈顶指针
public:
    //构造函数
    Stack(int size):stacksize(size),top(0){
        items = new DataType[size];
    }
    //析构函数
    ~Stack(){
        delete []items;//释放内存
        items=nullptr;
    }
    //判断是否为空
    bool isEmpty() const{
        return top == 0;
    }
    //判断是否已满
    bool isFull() const{
        return top == stacksize;
    }
    //入栈
    bool push(const DataType& item){
        if(isFull()){
            return false;
        }
        items[top++] = item;
        return true;
    }
    //出栈
    bool pop(DataType &item){
        if(isEmpty()){
            return false;
        }
        item = items[--top];
        return true;
    }
};

int main(){
    Stack stack(10);
    stack.push(1);
    stack.push(2);
    stack.push(3);
    DataType popitem;
    while (!stack.isEmpty()){
        stack.pop(popitem);
        cout << popitem << endl;
    }
}

  3. 使用类模板实现

    template<class DataType>//模板类
class Stack{
private:
    DataType *items;//栈数组
    int stacksize;//栈大小
    int top;//栈顶指针
public:
    //构造函数
    Stack(int size):stacksize(size),top(0){
        items = new DataType[size];
    }
    //析构函数
    ~Stack(){
        delete []items;//释放内存
    }
    //判断是否为空
    bool isEmpty() const{
        return top == 0;
    }
    //判断是否已满
    bool isFull() const{
        return top == stacksize;
    }
    //入栈
    bool push(const DataType& item){
        if(isFull()){
            return false;
        }
        items[top++] = item;
        return true;
    }
    //出栈
    bool pop(DataType &item){
        if(isEmpty()){
            return false;
        }
        item = items[--top];
        return true;
    }
};

int main(){
    Stack<int> stack(10);
    stack.push(1);
    stack.push(2);
    stack.push(3);
    int popitem;
    while (!stack.isEmpty()){
        stack.pop(popitem);
        cout << popitem << endl;
    }
}

三、模板类示例——栈

3.1 定长数组Array

template <class DataType,int len>
class Array{
private:
    DataType array[len];
public:
    Array(){
        memset(array,0,sizeof(array));
    }
    ~Array(){}//由于没有堆空间，析构函数可以为空

    //重写下标运算符，包含非const和const版本
    //非const版本,可以直接修改数组元素
    DataType& operator[](int index){
        return array[index];
    }
    //const版本，不可以修改数组元素
    const DataType& operator[](int index) const{
        return array[index];
    }
};


int main(){
    Array<int,10> array;
    array[0]=3;
    array[1]=4;
    for (int i = 0; i < 2; ++i) {
        cout<<array[i]<<endl;
    }
}

注意：
类模板可以有非通用类型参数：template <class DataType,int len>

  1. 通常是整型 （C++20标准可以用其它）；Array<int,10> array;
  2. 实例化模板时必须用常量表达式；Array<int,10> array;
  3. 模板中不能修改参数的值;
  4. 可以为非通用类型参数提供默认值。template <class DataType,int len=20> Array<int> array;
    优点：在栈上分配内存，易维护，执行速度快，合适小型数组。
    缺点：在程序中，不同的非通用类型参数将导致编译器生成不同的类。
    构造函数的方法更通用，因为数据的大小是类的成员（而不是硬编码），可以创建数组大小可变的类。

3.1 可变长度数组Vector

template<class DataType>
class Vector {
private:
    DataType *vector;
    int len;
public:
    Vector(int size = 2) : len(size) {
        vector = new DataType[size];
    }

    ~Vector() {
        delete[] vector;
        vector = nullptr;
    }

    //调整数组大小函数
    void resize() {
        DataType *new_vector = new DataType[len * 2];//重新申请一个两倍len大小的数组
        for (int i = 0; i < len; ++i) {//拷贝原始数据
            new_vector[i] = vector[i];
        }
        delete[] vector;//释放原来的数组
        vector = new_vector;//让数组指针指向新数组
        len = len * 2;//更新数组长度
    }

    //获取数组长度
    int getsize() {
        return len;
    }


    //重写下标运算符，包含非const和const版本
    //非const版本,可以直接修改数组元素
    DataType &operator[](int index) {
        if (index >= len) {
            resize();//如果要插入或修改的元素大于等于原始数组大小，则扩充数组大小
        }
        return vector[index];
    }

    //const版本，不可以修改数组元素，这里不用修改，因为是只读的
    const DataType &operator[](int index) const {
        return vector[index];
    }

    //由于可变数组类里面包含堆元素，因此要实现深拷贝，重写赋值运算符
    Vector<DataType>& operator=(const Vector<DataType> &vec) {
        //释放原内存
        delete[] vector;
        len = vec.len;
        vector = new DataType[len];//重新分配数组
        for (int i = 0; i < len; ++i) {
            vector[i] = vec.vector[i];    //拷贝数组中的元素
        }
        return *this;
    }
};
海绵宝宝丶哈
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ 类模板案例实践
03-12
实现一个通用的数组类，要求如下： * 可以对内置数据类型以及自定义数据类型的数据进行存储 * 将数组中的数据存储到堆区 * 构造函数中可以传入数组的容量 * 提供对应的拷贝构造函数以及operator=防止浅拷贝问题 * 提供尾插法和尾删法对数组中的数据进行增加和删除 * 可以通过下标的方式访问数组中的元素 * 可以获取数组中当前元素个数和数组的容量
C++ 类模板、函数模板全特化、偏特化的使用
12-20
一、类模板全特化、偏特化 #pragma once #include #include template class TC { public: TC() { std::cout << "泛化版本构造函数" < class TC { public: TC() { std::cout << "全特化版本构
C++面向对象程序设计 - 类模板
最新发布
觉醒法师的专栏
04-11 1061
C++允许使用函数模板，对于功能相同而数据类型不同的一些函数，不必一一定义各个函数，可以定义一个可以对任何类型变量进行操作的函数模板，在调用函数时，系统会根据实参的类型，取代函数模板中的类型参数，得到具体函数。有时两个或多个类，其功能是相同的，仅仅是数据类型不同。显然这种重复性工作是不必要的，C++在发展后期增加了模板（template）的功能，提供了解决这类的途径；可以声明一个通用的类模板，它可以有一个或多个虚拟的类型参数，创建可以重用的组件，这些组件可以处理多种数据类型，而不仅仅是单一的数据类型。
c++ 类模板
01-28
很不错的类模板，
C++ 泛型编程 之模板（template）
qq_24472227的博客
04-29 3934
C++的 函数模板与类模板
C++ 中的 模板类 简介
KamikazePilot的博客
09-11 688
这一章主要讲类模板，包括它的主要用法和作用，简单写了一下和普通类的异同。 本文主要为学习心得笔记，如有纰漏，欢迎指正
C++类模板
Tian Meng的博客
07-23 4762
类模板允许我们创建一个可以在工作在多种类型上的类，比如数组，链表，队列，栈等等。其工作原理就是用占位符代替实际的类型，当我们使用这个类模板时，再指定具体的类型。函数模板建议用typename描述通用数据类型，类模板建议用class。上述类模板例子中，MyArray类可以用于创建各种类型的数组。包括, 甚至是等。**需要注意的是，在创建模板类的实例时，我们必须指定模板参数。**例如，我们需要创建一个存储整数的MyArray，我们可以这样写。这里，模板参数时int，表示我们创建的MyArray将存储int。
入门指南：C++ 模板类详解
qq_46017342的博客
06-07 3587
入门指南：C++ 模板类详解
C++中的模板类
qq_39645539的博客
07-11 1万+
什么是模板类：C++发展到一定层次后，必然有部分代码存在仅传参的数据类型不同而内容一致的情况。因此，C++为解决此类场景，特推出模板类的使用。模板类是一种泛型技术，即与数据类型无关的通用程序设计技术。可以使我们设计出独立于数据类型的程序。模板类本身不占空间，当编译器执行到模板参数的调用时，当在程序中赋予具体的数据类型后并调用时则占用空间。常见的模板包含函数模板与类模板。模板的声明中class含义同typenamec，class并不是表明后续的类型名是一个类，而表示后续是一个通用的类型说明符。一、函数模板函数
C++模板（类模板）
weixin_62142545的博客
08-21 1762
C++类模板基础语法知识
C++类模板与模板类深入详解
09-04
C++类模板与模板类是C++编程中重要的特性，它们提供了泛型编程的能力，允许程序员编写出能够处理多种数据类型的一般性代码。本文将深入探讨这两个概念及其相关知识点。 1. 关键字`typename`与`class`： 在C++的模板...
C++类模板案例.zip
08-11
C++类模板案例.zip
C++函数模板和类模板
Gefangenes的博客
06-25 1170
和其他类模板一样，派生类模板Derived在定义对象时需要明确给出派生类模板中类型参数所指代的实际数据类型。编译器在编译到使用类模板定义对象语句时，将首先按照所给定的实际数据类型对类模板进行实例化，生成一个实例类。在编译到派生类Derived的定义代码时，编译器将按照所给定的实际数据类型double对类模板Base进行实例化，生成一个double型的实例类，最终派生类Derived继承的是该实例类。使用类模板定义对象时，需要明确给出类模板中类型参数所指代的实际数据类型。o1(10.5,6);
C++——模板（超详细的模板解析）
热门推荐
JAN6055的博客
04-01 5万+
超详细的C++模板知识列表，持续维护。
【C++】类模板
debug...
07-24 1717
C++类模板
C++：类模板详解
青瓦松
12-16 902
C++：类模板 四、类模板 1、类模板不可使用自行类型推导，须显式指定类型 2、类模板可有默认类型参数 #include <iostream> #include <string> using namespace std; // AGETYPE = int: 指定AGETYPE默认类型参数为int template <class NAMETYPE, class AGETYPE=int> class Person { private: NAMETYPE name

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值