【C++ Template】 --- 模板初阶

最新推荐文章于 2024-04-08 22:57:38 发布
最新推荐文章于 2024-04-08 22:57:38 发布
阅读量1k 收藏
点赞数 1
分类专栏： C++之STL学习笔记 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42296879/article/details/129954762
版权

目录

模板

模板就是建立通用的模具，大大提高复用性，
C++另一种编程思想称为 泛型编程 ，主要利用的技术就是模板
C++提供两种模板机制**:函数模板和类模板**

1、函数模板

1.1 函数模板语法

函数模板作用：
建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。

语法：
template < typename T>
函数声明或定义

解释：
template — 声明创建模板
typename — 表面其后面的符号是一种数据类型，可以用class代替
T — 通用的数据类型，名称可以替换，通常为大写字母

【例子：利用函数模板进行交换】

template<typename T> //声明一个模板，注意不需要分号
void MySwap(T &a,T &b)
{
    T temp = a;
    a = b;
    b = temp;
}
template<typename T>
void func()
{
    cout << "func调用 " << endl;
}
void My_TemplateFunc()
{
    int a = 12;
    int b = 34;

    //1、自动类型推导 --- 让编译器推导传入的参数是什么数据类型，然后进行交换
    MySwap(a, b);
    cout << "a = " << a << "\tb = " << b << endl;

    //2、显式指定类型 --- 告诉编译器需要转换哪一种类型
    MySwap<int>(a, b);
    cout << "a = " << a << "\tb = " << b << endl;
}

1.2 函数模板注意事项

函数模板注意事项：1、自动类型推导，必须推导出一致的数据类型T,才可以使用

void My_TemplateFunc()
{
    /* 函数模板注意事项：1*/
    int a = 12;
    char c = 'w';
    MySwap(a, c); //err，推导不出一致的T类型
}

函数模板注意事项：2、模板必须要确定出T的数据类型，才可以使用

void My_TemplateFunc()
{
    /* 函数模板注意事项：2*/
    int a = 12;
    int b = 34;

    func();  //err,没有指定T的数据类型
    func<int>(); //OK
}

1.3 函数模板案例

函数模板代表了一个函数集合，该函数模板与类型无关，在使用时被参数化，根据实参类型产生适用于不同类型的函数。
下例使用函数模板对一个字符数组和一个整形数组进行排序（使用冒泡算法，降序排列）

template<typename T>
void mySort(T arr[], int len)
{
    for (int i = 0; i < len; i++)
    {
        int max = i; //认定最大值的下标
        for (int j = i + 1; j < len; j++)
        {
            //认定的最大值arr[max] < 遍历的数组，说明arr[j]为最大值，则更新下标
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            MySwap(arr[max], arr[i]); 
        }
    }
}
template<typename T>
void PrintFunc(T arr[],int len)
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << "  ";
    }
    cout << endl;
}
void My_TemplateFunc_SortCase()
{
    char ch[] = "bafsxc";
    int len = sizeof(ch) / sizeof(ch[0]);
    mySort(ch, len);
    PrintFunc(ch, len);

    int arr[] = { 23,6,56,451,3,8,9,5,90 };
    int num = sizeof(arr) / sizeof(arr[0]);
    mySort(arr, num);
    PrintFunc(arr, num);
}

结果：
在这里插入图片描述

1.4 普通函数与函数模板的区别

1、普通函数调用时可以发生自动类型转换（隐式类型转换）
2、函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
3、函数模板调用时，如果利用显示指定类型的方式，可以发生隐式类型转换
1.4.1 普通函数调用会进行隐式类型转换
int ADD(int a, int b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';
    cout << ADD(a, c) << endl;
}

在这里插入图片描述

输出109：在ADD()函数中，把字符型C的值隐式转换为ASCII码值，然后进行累加.

1.4.2 函数模板调用时，如果利用自动类型推导，不会发生隐式类型转换
template<typename T>
T MyAdd(T a, T b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';

    cout << MyAdd(a, c) << endl;  //err
}

在这里插入图片描述

1.4.3 函数模板调用时，如果利用显示指定类型的方式，可以发生隐式类型转换
template<typename T>
T MyAdd(T a, T b)
{
    return a + b;
}
void My_TemplateFunc_Func_diff()
{
    int a = 10;
    int b = 20;
    char c = 'c';

    //显示指定 --- 可以发生隐式类型转换
    cout << MyAdd<int>(a, c) << endl;  //OK
}

在这里插入图片描述

1.5 普通函数与函数模板的调用规则

调用规则如下：
（1）如果函数模板和普通函数都可以实现， 优先调用普通函数
（2）可以通过 空模板参数列表 来 强制调用函数模板
（3）函数模板也 可以发生重载
（4）如果函数模板可以产生更好的匹配, 优先调用函数模板

1.5.1 规则一
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //1. 如果函数模板和普通函数都可以实现， 优先调用普通函数
    MyPrint(10, 20);   //规则一
}
1.5.1 规则二
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;
    
    //2、空模板参数列表，强制调用函数模板
    MyPrint<>(a, b);   //调用函数模板
}
1.5.1 规则三
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
template<typename T>
void  MyPrint(T a, T b，, T c)
{
    cout << "调用 重载的 函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //3、函数模板也 可以发生重载
    MyPrint(a, b, 100);
}
1.5.1 规则四
void MyPrint(int a, int b)
{
    cout << "调用普通函数" << endl;
}
template<typename T>
void  MyPrint(T a, T b)
{
    cout << "调用函数模板" << endl;
}
template<typename T>
void  MyPrint(T a, T b，, T c)
{
    cout << "调用 重载的 函数模板" << endl;
}
void My_TemplateFunc_CallFunc()
{
    int a = 10;
    int b = 20;

    //4、如果函数模板可以产生更好的匹配, 优先调用函数模板
    char c1 = 'a';
    char c2 = 'b';
    MyPrint(c1, c2);  //调用的是 函数模板
}

结果
在这里插入图片描述

1.6 模板的局限性

1.6.1 模板的通用性并不是万能的
template<class T>
void f(T a, T b)
{
a = b;
}

在上述代码中提供的赋值操作，如果传入的a和b是一个数组，就无法实现了

template<class T>
void f(T a, T b)
{
if(a > b) { ... }
}

在上述代码中，如果T的数据类型传入的是像Person这样的自定义数据类型，也无法正常运行
因此C++为了解决这种问题，提供模板的重载，可以为这些特定的类型提供具体化的模板

1.6.2 为特定的类型提供具体化的模板
template<class T>
bool myCompare(T &a, T &b)
{
    if (a == b) { return true; }
    else { return false; }
}
class Person
{
public:
    Person(string name, int age)
    {
        this->m_Age = age;
        this->m_Name = name;
    }

    ~Person()
    {

    }

    string m_Name;
    int m_Age;
};
//具体化，显示具体化的原型和定意思以template<>开头，并通过名称来指出类型
//具体化优先于常规模板;利用具体化的Person的版本 实现比较代码，会被优先调用
template<>bool myCompare(Person &p1, Person &p2)
{
    if (p1.m_Name == p2.m_Name && p1.m_Age == p2.m_Age)
    {
        return true;
    }
    else
    {
        return false;
    }

}
void My_TemplateFunc_Backpoint()
{
    int a = 10;
    int b = 20;
    cout << myCompare(a, b) << endl;
   
    //自定义数据类型，不会调用普通的函数模板
	//可以创建 具体化的Person数据类型的模板，用于特殊处理这个类型
    Person p1("Tom", 10);
    Person p2("Tom", 10);
    bool ret = myCompare(p1, p2);
    if (ret) { cout << "p1==p2" << endl; }
    else { cout << "p1 != p2" << endl; }
}

在这里插入图片描述

2、类模板

类模板作用
建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表。

2.1 类模板语法

类模板和函数模板语法相似，在声明模板template后面加类，此类称为类模板
语法：

template < typename T >
类

template<class NameType,class AgeType>
class MyPerson01
{
public:
    template<class NameType, class AgeType>
    MyPerson01(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "name:" << this->m_Name << endl;
        cout << "age:" << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType  m_Age;
};
void My_TemplateClass_Basic()
{
    MyPerson01<string, int> p1("Tom", 18);
    p1.Show();
}

在这里插入图片描述

2.2 类模板与函数模板区别

  1. 类模板 没有自动类型推导 的使用方式 — 只能使用 显示指定方式
  2. 类模板在模板参数列表中可以有默认参数
template<class NameType, class AgeType = int>
class MyPerson0
{
public:
    MyPerson0(NameType name, AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "name:" << this->m_Name << endl;
        cout << "age:" << this->m_Age << endl;
    }

    NameType m_Name;
    AgeType  m_Age;
};
void My_TemplateClass_TemplateFunc_diff()
{
    //MyPerson p("lslslsl", 200);  //err ，自动类型推导不适用于 类模板

    MyPerson<string, int> p1("sssss", 200);  // 必须使用显示指定类型的方式，使用类模板
    p1.Show();

    MyPerson<string> p2("gggggg", 345);  //  类模板在模板参数列表中可以有默认参数,直接在模板后面指定即可
    p2.Show();
}

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

2.3 类模板中成员函数创建时机

普通类中的成员函数：一开始就可以创建
类模板中的成员函数：在调用时才去创建

class MyPerson03
{
public:
    void ShowPerson03()
    {
        cout << "Show Person03 类" << endl;
    }
};
class MyPerson04
{
public:
    void ShowPerson04()
    {
        cout << "Show Person04 类" << endl;
    }
};
template<class T>
class MyClass
{
public:
    T obj;

    //类模板中的成员函数,并不是一开始就创建的，而是在模板调用时再生成
    void FUNC1()
    {
        obj.ShowPerson03();
    }
    void FUNC2()
    {
        obj.ShowPerson04();
    }
};
void My_TemplateClass_CreatTime()
{
    MyClass<MyPerson03> p1;
    p1.FUNC1();
    p1.FUNC2(); //compile err, 编译会出错，说明函数调用 才会去 创建成员函数
}

在这里插入图片描述

2.4 类模板对象做函数参数

类模板实例化出的对象，向函数传参的方式

三种传入方式：
1. 指定传入的类型 — 直接显示对象的数据类型
2. 参数模板化 — 将对象中的参数变为模板进行传递
3. 整个类模板化 — 将这个对象类型 模板化进行传递

template<class T1,class T2>
class MyPerson05
{
public:
    MyPerson05(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    void Show()
    {
        cout << "NAME: " << this->m_Name << "\tAGE: " << this->m_Age << endl;
    }

    T1 m_Name;
    T2 m_Age;
};

void My_TemplateClass_Func_data()
{
    MyPerson05<string, int> p1("sdsdsds", 100);
    ShowPerson01(p1);//1. 指定传入的类型 --- 直接显示对象的数据类型


    MyPerson05<string, int> p2("ldfldldlf", 200);
    ShowPerson02(p2);//2. 参数模板化-- - 将对象中的参数变为模板进行传递


    MyPerson05<string, int> p3("ppppppp", 34);
    ShowPerson03(p3);//3. 整个类模板化-- - 将这个对象类型 模板化进行传递
}
2.4.1 指定传入的类型
void ShowPerson01(MyPerson05<string,int> &p)
{
    p.Show();
}

在这里插入图片描述

2.4.2 参数模板化
template<class T1,class T2>
void ShowPerson02(MyPerson05<T1, T2> &p)
{
    p.Show();
    cout << "T1 的类型为：" << typeid(T1).name() << endl;
    cout << "T2 的类型为：" << typeid(T2).name() << endl;
}

在这里插入图片描述

2.4.3 整个类模板化
template<class T>
void ShowPerson03(T &p)
{
    p.Show();
    cout << "T 的类型为：" << typeid(T).name() << endl;
}

在这里插入图片描述

2.4.4 总结

通过类模板创建的对象，可以有三种方式向函数中进行传参
使用比较广泛是第一种：指定传入的类型

2.5 类模板与继承

当类模板碰到继承时，需要注意一下几点：

  1. 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型； 如果不指定，编译器无法给子类分配内存
  2. 如果想灵活指定出父类中T的类型，子类也需变为类模板
2.5.1 注意点（1）

在这里插入图片描述
指定父类T类型后

template<class T>
class Base
{
public:
    Base()
    {
        cout << "父类中 T 的类型为：" << typeid(T).name() << endl;
    }

    T m;
};
class Son1 : public Base<int>
{
public:

};
2.5.2 注意点（2）
template<class T>
class Base
{
public:
    Base()
    {
        cout << "父类中 T 的类型为：" << typeid(T).name() << endl;
    }

    T m;
};

template<class T1,class T2>
class Son2 :public Base<T2>
{
public:
    Son2()
    {
        cout << "子类中 T1 的类型为：" << typeid(T1).name() << endl;
        cout << "子类中 T2 的类型为：" << typeid(T2).name() << endl;
    }

    T1 obj;

};
void My_TemplateClass_Inheritance()
{
    Son2<int,char> s1;  
}

此时， int为子类Son2中的 T1的类型，char为子类Son2中的 T2的类型 ； 并且由于子类Son2继承的父类Base，此时会把T2 当作父类的T类型传给父类，因此，父类的 T 为char

在这里插入图片描述

2.6 类模板成员函数类外实现

类模板中成员函数类外实现时，需要加上模板参数列表

template<class T1,class T2>
class Myperson06
{
public:
    Myperson06(T1 name, T2 age);
    void ShowMyPerson06();

    T1 m_Name;
    T2 m_Age;
};
template<class T1,class T2>
Myperson06<T1,T2>::Myperson06(T1 name ,T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}
template<class T1,class T2>
void Myperson06<T1, T2>::ShowMyPerson06()
{
    cout << "NAME : " << this->m_Name << "\tAGE: " << this->m_Age << endl;
}
void My_TemplateClass_OutOfClass()
{
    Myperson06<string,int> p1("sdsdsdsds",5467);
    p1.ShowMyPerson06();

}

2.7 类模板分文件编写

问题：类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到
解决：

解决方式1：直接包含.cpp源文件
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制

person.hpp中代码：

#pragma once
#include <iostream>
using namespace std;
#include <string>
template<class T1, class T2>
class Person 
{
public:
	Person(T1 name, T2 age);
	void showPerson();
public:
	T1 m_Name;
	T2 m_Age;
};
//构造函数 类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
	this->m_Name = name;
	this->m_Age = age;
}
//成员函数 类外实现
template<class T1, class T2>
void Person<T1, T2>::showPerson()
{
	cout << "姓名: " << this->m_Name << " 年龄:" << this->m_Age << endl;
}

类模板分文件编写.cpp中代码

#include<iostream>
using namespace std;
//#include "person.h"
#include "person.cpp" //解决方式1，包含cpp源文件

//解决方式2，将声明和实现写到一起，文件后缀名改为.hpp
#include "person.hpp"

void test01()
{
	Person<string, int> p("Tom", 10);
	p.showPerson();
}
int main() 
{
	test01();
	system("pause");
	return 0;
}

主流的解决方式是第二种，将类模板成员函数写到一起，并将后缀名改为.hpp

2.8 类模板与友元

全局函数类内实现 - 直接在类内声明友元即可
全局函数类外实现 - 需要提前让编译器知道全局函数的存在

2.8.1 类内实现
template<class T1, class T2>
class Myperson08
{
public:
    Myperson08(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    //类内实现   ---  通过全局函数打印Myperson08类的信息
    friend void PrintMyperson08Info(Myperson08<T1,T2> p)
    {
        cout << "NAME; " << p.m_Name << "\tAGE: " << p.m_Age << endl;
    }

private:
    T1 m_Name;
    T2 m_Age;

};
void My_TemplateClass_Friend()
{
    Myperson08<string, int> p1("vbcgghcv", 34);
    PrintMyperson08Info(p1);
}

在这里插入图片描述

2.8.1 类外实现
//如果全局函数 是类外实现，需要在程序最开始声明该函数 和 类模板
template<class T1, class T2> class Myperson08;   //声明类模板
template<class T1, class T2>
void PrintMyperson08Info2(Myperson08<T1, T2> p) //声明该函数
{
    cout << "类外实现内容为" << endl;
    cout << "NAME; " << p.m_Name << "\tAGE: " << p.m_Age << endl;
}

//通过全局函数打印M有person08类的信息
template<class T1, class T2>
class Myperson08
{
public:
    Myperson08(T1 name, T2 age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    //类外实现   ---  通过全局函数打印Myperson08类的信息
    //加一个空参数模板列表
    friend void PrintMyperson08Info2<>(Myperson08<T1, T2> p);

private:
    T1 m_Name;
    T2 m_Age;
};
void My_TemplateClass_Friend()
{
    Myperson08<string, int> p2("nnnnnnn", 88);
    PrintMyperson08Info2(p2);
}

在这里插入图片描述

just kidding°
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++graph-template-library项目源码.zip
10-18
C++graph-template-library项目源码.zipC++graph-template-library项目源码.zipC++graph-template-library项目源码.zipC++graph-template-library项目源码.zip
C++模板详解：泛型编程、模板原理、非类型模板参数、模板特化、分离编译
林慢慢的博客
06-01 1674
泛型编程、模板原理、非类型模板参数、模板特化、分离编译
C++： C++模板＜template＞
C++ JAVA的专栏
02-09 993
C++：C++模板＜template＞
C++模板template
dongbab的博客
01-14 221
C++ template
C++编程语言中模板（template）介绍
liitdar的博客
06-05 7982
泛型编程是一种代码编写方式，通过使用泛型编程，可以编写出独立于任何特定类型的代码。模板是泛型编程的基础，是创建泛型函数或类的蓝图（公式）。C++的STL(Standard Template Library)容器及其迭代器和算法，都是泛型编程的例子，它们都使用了模板的概念。每个容器都有一个单一的定义，比如vector，我们可以定义许多包含不同类型元素的vector，比如：“vector ”或“vector ”。C++的模板包括函数模板和类模板。
C++模板（template）详解
2301_81261654的博客
03-09 7900
原因是在链接过程中，编译器找不到模板函数的定义，因为在使用模板时，.h文件中的模板的声明知晓了模板参数的类型，但在.cpp文件中的模版不知道，所以.cpp中模板的定义没法实例化,也就没法在编译阶段生成一份经过实例化的具体的代码，这将导致程序在链接阶段找不到模板函数的实现而报链接错误。这样一来，在调用Add函数的时候，其本质上是调用了上面的经过实例化的模板函数，这样做的好处就是，程序员就可以不用对每一种数据类型都去实现对应的函数，大大提高了效率，而且只实现这么一份通用的模板函数可以使其更易于维护。
基于C++的ACM-ICPC模板
02-22
【标题】：“基于C++的ACM-ICPC模板” 在计算机编程竞赛中，特别是国际大学生程序设计竞赛（ACM-ICPC）中，拥有一套高效、灵活且经过优化的编程模板是至关重要的。这个“基于C++的ACM-ICPC模板”集合了一套专门为...
c++运行库2015-2019
05-22
- 它们包含了运行由Visual C++编译器编译的应用程序所需的运行时组件，如C++标准库、MFC（Microsoft Foundation Classes）、ATL（Active Template Library）等。 - 每个年度版本可能包含不同版本的运行库，例如从...
实验0-1 Template工程模板-新建工程章节使用_Template工程模板-新建工程_
09-30
"实验0-1 Template工程模板-新建工程章节使用_Template工程模板-新建工程_"的标题和描述揭示了这是一个教学资源，旨在指导用户如何在Keil uVision中创建和管理工程。 首先，我们来理解什么是"工程模板"。在Keil ...
C++版本Savitzky-Golay 滤波器
08-20
C++版本Savitzky-Golay 滤波器，包括序列噪声去除与插值等等。
深入解析template，掌握C++模板的精髓！
最新发布
Lion_Long的博客
04-08 1497
模板是 C++ 中最强大和最广泛使用的方法之一，允许我们编写通用程序。它允许我们定义泛型函数和类。它促进了泛型编程，不需要为不同的参数编写相同的函数或方法。可以将模板定义为创建泛型类和函数的蓝图。C++ 模板背后的想法很简单。将数据类型作为参数传递，不需要为不同的数据类型编写相同的代码。在 C++ 的模板中使用两个关键字——template和typename来实现泛型编程。注意：typename 关键字始终可以替换为class关键字。像迭代器这样的库容器。
【C++】模板template
qq_52572621的博客
11-15 2082
1、我们使用模板的目的就是为了提高代码的复用性，减少重复代码的编写； 2、函数模板的底层并不是只有一个函数完成的，它是根据你传入参数的类型，给你分配一个适用你传入类型的函数；如果你连续传入n个类型，他就会给你分配n个函数；
C++模板——template
原来45的博客
06-11 3万+
目录1. 模板2. 函数模板2.1 函数模板概念2.2 函数模板格式2.3 函数模板原理2.4 函数模板的实例化2.5 模板参数的匹配原则2.6 声明定义分离3. 类模板3.1 类模板格式3.2 类模板的实例化3.3 类模板中函数放在类外进行定义时4. 模板分离编译4.1 什么是分离编译4.2 模板的分离编译5. 缺省值，返回值6. 总结...
C语言实现模版
zoomdy's blog
02-02 2万+
C语言有两把双刃剑，一把是“指针”，另一把是“宏”。这回咱就用“宏”来实现C++中才有的模版。这里的模版实现一个很简单的加法函数，同一个函数代码可以处理不同类型的加法运算。 http://blog.csdn.net/zoomdy/article/details/79242528 mingdu.zheng at gmail dot com C++的实现 template &lt;cl...
C++模板(template)使用介绍
chenchen410的专栏
09-23 4万+
1. 模板的概念。我们已经学过重载(Overloading)，对重载函数而言,C++的检查机制能通过函数参数的不同及所属类的不同。正确的调用重载函数。例如，为求两个数的最大值，我们定义MAX()函数需要对不同的数据类型分别定义不同重载(Overload)版本。//函数1.int max(int x,int y);{return(x>y)?x:y ;}//函数2.float max( float x
c++ 模板的使用
lccrun的博客
03-08 1428
如何使用C++模板
c++中的template理解
Arcobaleno
04-10 5万+
有必要记一下这种一眼看上去就很高级的用法。还是编程不够多。都没用过这个。 相信用过c++的人，即便没用过，也肯定都听说过模板类这个词。嗨不巧了，今天讲的就是模板类。 模板是c++支持参数化多态的工具，使用模板可以使用户为类或者函数声明一种一般模式，使得类中的某些数据成员或者成员函数的参数、返回值取得任意类型。因此可以说，模板是一种对类型进行参数化的工具。 template<class ...
C++ 类模板（template）详解
热门推荐
qq_54169998的博客
10-27 5万+
1.类模板的使用 1.1为什么需要类模板 类模板与函数模板的定义和使用类似，有时，有两个或多个类，其功能是相同的，仅仅是数据类型不同，我们可以通过如下面语句声明了一个类模板： template <typename T> class A { public: A(T t){ this->t = t; } T& getT(){ return t; } public: T t; }; 1.2类模板定义 类模板由模板说明和类说明构成 模板说...
Dev-C++集成开发环境使用教程
"Dev-C++ 编译器是一款流行的开源集成开发环境，特别适合初学者和需要使用GNU GCC编译器的程序员。本资源提供了一份关于Dev-C++的使用说明，包括如何启动IDE、新建源程序、编辑代码、保存文件以及进行简单的调试。" ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值