C++(week12): C++基础 第九章:模板

原创 已于 2024-08-08 22:47:58 修改 · 1.1k 阅读 · 25 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
C++训练营

当前文章被收录于：

C++训练营
36 篇文章 19 人学习

C++长期：第一阶段：C语言、数据结构与算法。第二阶段：Linux系统编程(文件、进程、线程、网络)、数据库、git。第三阶段：C++基础、C++进阶、Redis、Qt、Reactor、workflow 【内容涉及考研内容的：C语言、数据结构与算法、操作系统、计算机组成原理、计算机网络、数据库】

订阅专栏 查看详情
于 2024-07-17 10:21:42 首次发布

文章目录

第九章：模板

模板template是一种通用的描述机制，使用模板允许使用通用类型来定义函数或类。在使用时，通用类型可被具体的类型，如 int、double 甚至是用户自定义的类型来代替。模板引入一种全新的编程思维方式，称为“泛型编程”或“通用编程”。


1.为什么要定义模板

像C/C++/Java等语言，是编译型语言，先编译后运行。它们都有一个强大的类型系统，也被称为强类型语言，希望在程序执行之前，尽可能地发现错误，防止错误被延迟到运行时。所以会对语言本身的使用造成一些限制，称之为静态语言。与之对应的，还有动态语言，也就是解释型语言。如javascript/python/Go，在使用的过程中，一个变量可以表达多种类型，也称为弱类型语言。因为没有编译的过程，所以相对更难以调试。


例如，想要实现能够处理各种类型参数的加法函数
以前我们需要进行函数重载（函数名相同，函数参数不同）

int add(int x, int y)
{
 return x + y;
}

double add(double x, double y)
{
 return x + y;
}

long add(long x, long y)
{
 return x + y;
}

string add(string x, string y)
{
 return x + y;
}

模板：将数据类型作为参数
上面的问题用函数模板的方式就可以轻松解决：

//希望将类型参数化
//使用class关键字或typename关键字都可以
template <class T>
T add(T x, T y)
{
	return x + y;
}

int main(void){
	cout << add(1,2) << endl;
	cout << add(1.2,3.4) << endl;
	return 0;
}

函数模板的优点：
不需要程序员定义出大量的函数，在调用时实例化出对应的模板函数，更“智能”


2.模板的定义

模板作为实现代码重用机制的一种工具，它可以实现类型参数化，也就是把类型定义为参数，从而实现了真正的代码可重用性。(以前的代码可重用，例如函数重载，只是调用的时候代码可重用了，但是重载的代码还是很多的。)

模板可以分为两类，一个是函数模版，另外一个是类模板。通过参数实例化定义出具体的函数或类，称为模板函数或模板类。模板的形式如下：

在这里插入图片描述
模板参数是一个更大的概念，包含了类型参数和非类型参数，这里的T1/T2属于类型参数，代表了类型。


模板发生的时机是在编译时
模板本质上就是一个代码生成器，它的作用就是让编译器根据实际调用来生成代码。
编译器去处理时，实际上由函数模板生成了多个模板函数，或者由类模板生成了多个模板类。


函数模板：调用函数，在编译时会实例化出相应的模板函数。

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


(1)函数模板

由函数模板到模板函数的过程称之为实例化

过程：函数模板 → 生成相应的模板函数 → 编译 → 链接 → 可执行文件

//函数模板
template <class T>
T add(T t1, T t2){
    return t1 + t2;
}
①隐式实例化

进行模板实例化时，并没有指明任何类型，函数模板在生成模板函数时通过传入的参数类型推导出模板类型，这种做法称为隐式实例化。

template <class T>
T add(T t1,T t2)
{ return t1 + t2; }

void test0(){
    short s1 = 1, s2 = 2;
    int i1 = 3, i2 = 4;
    long l1 = 5, l2 = 6;
    double d1 = 1.1, d2 = 2.2;
    
    cout << "add(s1,s2): " << add(s1,s2) << endl;
    cout << "add(i1,i2): " << add(i1,i2) << endl;
    cout << "add(l1,l2): " << add(l1,l2) << endl;
    cout << "add(d1,d2): " << add(d1,d2) << endl;  
}

②显式实例化

在使用函数模板时还可以在函数名之后直接写上模板的类型参数列表，指定类型，这种用法称为显式实例化。

template <class T>
T add(T t1,T t2)
{ return t1 + t2; }

void test0(){
    int d1 = 1.5, i2 = 2.5;
    cout << "add(d1,d2): " << add<int>(d1,d2) << endl;  //显式实例化
}

①函数模板的重载

函数模板的重载分为：
(1)函数模板与函数模板重载
(2)函数模板与普通函数重载


<1>函数模板与函数模板重载

代码链接：https://github.com/WangEdward1027/Object-Oriented/blob/main/template/TemplateOverload.cpp

隐式实例化有冲突时，需要显式实例化。
但显式实例化可能选错类型，造成错误，精度损失。

在这里插入图片描述

于是考虑，重载函数模板：有两个模板参数。

在这里插入图片描述


在这里插入图片描述


缺省，第一个参数如果匹配，缺省的第二个参数会自动推导。

编译器优先选择：
①参数进行类型转换少的模板。
②如果类型转换都一样多，比如第一个参数和模板要求不一样，则选择模板参数少的模板。
在这里插入图片描述


在一个源文件中定义多个通用模板的写法应该谨慎使用（尽量避免），如果实在需要也尽量使用隐式实例化的方式进行调用，编译器会选择参数类型最匹配的模板（通常是参数类型需要更少转换的模板）。


函数模板与函数模板重载的条件：
(1)首先，名称必须相同（显然）
(2)模板参数列表中的模板参数在函数中所处位置不同 —— 但不建议进行这样的重载。
(3)模板参数的个数不一样时，可以构成重载（相对常见）


(2)的例子

template <class T1, class T2>  
T1 add(T1 t1, T2 t2)
{
	cout << "模板一" << endl;
	return t1 + t2;
} 

template <class T1, class T2>  
T1 add(T2 t2, T1 t1)
{
	cout << "模板二" << endl;
	return t1 + t2;
}

int a = 10;
double b = 1.2;
cout << add(a,b) << endl; //error 冲突,两个模板都能行得通,且同样优先级
cout << add<int>(a,b) << endl; //模板一
cout << add<double>(a,b) << endl;  //模板二。缺省,T2推导出int

<2>函数模板与普通函数重载

代码链接：https://github.com/WangEdward1027/Object-Oriented/blob/main/template/TemplateOverload2.cpp

普通函数优先于函数模板执行——因为普通函数更快

在这里插入图片描述

如果没有普通函数，就会调用上面的函数模板，实例化出相应的模板函数。尽管s1/s2的类型相同，也是可以使用该模板的。
—— T1/T2并不一定非得是不同类型，能推导出即可。
当然，如果采用显示实例化的方式调用，肯定是调用函数模板。


②头文件与实现文件形式 （重要）

从原理上进行分析，函数模板定义好之后并不会直接产生一个具体的模板函数，只有在调用时才会实例化出具体的模板函数。

在这里插入图片描述

解决方法 —— 在”实现文件“中要进行调用，因为有了调用才有推导，才能由函数模板生成需要的函数

//add.cc
template <class T>
T add(T t1, T t2)
{
	return t1 + t2;
}

//在这个文件中如果只是写出了函数模板的实现
//并没有调用的话，就不会实例化出模板函数
void test1(){ 
	cout << add(1,2) << endl;
}

在这里插入图片描述

但是在“实现文件”中对函数模板进行了调用，这种做法不优雅 。

设想：如果在测试文件调用时，在推导的过程中，看到的是完整的模板的代码，那么应该可以解决问题

//add.h
template <class T>
T add(T t1, T t2);

#include "add.cc"

可以在头文件中加上#include “add.cc”，即使实现文件中没有调用函数模板，单独编译testAdd.cc，也可以发现问题已经解决。

因为本质上相当于把函数模板的定义写到了头文件中。


总结：
(1)对模板的使用，必须要拿到模板的全部实现，如果只有一部分，那么推导也只能推导出一部分，无法满足需求。
(2)换句话说，就是模板的使用过程中，其实没有了头文件和实现文件的区别，在头文件中也需要获取模板的完整代码，不能只有一部分。

C++的标准库都是由模板开发的，所以经过标准委员会的商讨，将这些头文件取消了后缀名，与C的头文件形成了区分；这些实现文件的后缀名设为了tcc

C++标准委员会规定：使用模板时，头文件不加后缀名，实现文件后缀是.tcc。头文件中包含了实现文件。

在这里插入图片描述


③特化模板

代码链接：https://github.com/WangEdward1027/Object-Oriented/blob/main/template/TemplateSpecialization.cpp

在这里插入图片描述

内存泄露。记得要delete。
在这里插入图片描述


特化模板：template <>
在这里插入图片描述
在这里插入图片描述

//特化模板
//这里就是告诉编译器这里是一个模板
template <>
const char * add<const char *>(const char * p1,const char * p2){
    //先开空间
    char * ptmp = new char[strlen(p1) + strlen(p2) + 1]();
    strcpy(ptmp,p1);
    strcat(ptmp,p2);
    return ptmp;
}

void test0(){
    //通用模板无法应对如下的调用
    const char * p = add<const char *>("hello",",world");
    cout << p << endl;
    delete [] p;
}

注意：
使用特化模板，前提是有通用模板。
特化模板的形式(函数名、参数列表)，要与通用模板一致。
特化模板，就是为了解决通用模板无法处理的特殊类型的操作。


<1>模板的全特化 (完全特化)

模板的全特化：将模板参数列表中的全部参数，以特殊版本的形式展现出来


<2>模板的偏特化，部分特化 (不完全特化的模板)

模板的偏特化：将模板参数列表中的部分参数，以特殊版本的形式写出

在这里插入图片描述

在这里插入图片描述


④使用模板的规则 （重要）

1.一个文件中避免定义多个通用模板 (不确定应该调用哪个模板)
2.调用函数模板，尽量隐式调用，让编译器推导出类型
3.无法使用隐式调用的场景只指定必须要指定的类型
4.需要使用特化模板的场景就根据特化模板将类型指定清楚。


3举例：
特例化< >中，只填返回值类型，而不是填三个参数，否则指定太多了，无法使用隐式实例化。
只在必须显式实例化的地方写，只指定必要的。
在这里插入图片描述


4.举例
要特化的时候，在定义和调用的时候，加上<>，告诉编译器这是特化模板。
在这里插入图片描述


⑤模板的参数类型

1.模板的参数类型：
(1)类型参数 (模板参数)
之前的T/T1/T2等等称为模板参数，也称为类型参数，类型参数T可以写成任何类型
(2)非类型参数 (non-type template parameter)
非类型参数，必须是整型数据， char/short/int/long/size_t等。不能是float、double等。


2.模板参数列表、函数参数列表
<>叫模板参数列表。除了可以放类型参数，还可以放非类型参数
()叫函数参数列表

在这里插入图片描述

非类型参数：
①传入时指定
②加默认值
在这里插入图片描述


优先级：指定的类型 > 推导出的类型 > 类型的默认参数


轮到默认值的情况：前两种都走不通
在这里插入图片描述

不过尽量从右往左赋默认值：
在这里插入图片描述


⑥成员函数模板

显式实例化
在这里插入图片描述

默认值
在这里插入图片描述


以往成员函数能用的 static、const、&，在模板中都可以用
在这里插入图片描述

只有虚函数不可以用模板。模板是编译时生效，虚函数是运行时生效。
在这里插入图片描述

声明与实现分离：
在这里插入图片描述



(2)类模板

类模板的声明和实现都要写在头文件中


(1)类模板定义

代码链接：https://github.com/Edward/Object-Oriented/tree/main/template/类模板

类模板的定义：

template <typename T, ...>
class 类名{
//类定义．．．．．．
};

示例，用类模板的方式实现一个Stack类，可以存放任意类型的数据
——使用函数模板实例化模板函数使用类模板实例化模板类

在这里插入图片描述


类模板的成员函数如果放在类模板定义之外进行实现，需要注意：
(1)需要带上template模板形参列表（如果有默认参数，此处不要写，写在声明时就够了）
(2)在添加作用域限定时需要写上完整的类名和模板实参列表

在这里插入图片描述

加上<>，表明这是一个类模板，而不是一个普通类。
//TemplateClass.cc
在这里插入图片描述


(2)类模板的特化
类模板的特化:
template<>   		  //尖括号里不写
class 类名<特化的类型> //类的声明后跟具体的类型

//定义一个通用的类模板
template <typename T>
class Box{
	//...
}

//为int类型提供全特化
template <>
class Box<int>{
	//...
}

完整代码：

//类模板、类模板的特化

#include <iostream> 
#include <string>
using std::cout;
using std::endl;
using std::string;

//通用的类模板
template<typename T>
class Box
{
public:
    Box(T value = 65)
    :_value(value)
    {}

    T getValue() const{
        return _value;   
    }
private:
    T _value;
};


class Point
{
public:
    Point(int x = 0, int y =0)
    : _ix(x)
    , _iy(y)
    {

    }

    void print() const{
        cout << "(" <<_ix << "," << _iy << ")" << endl;
    }

private:
    int _ix;
    int _iy;
};


//类模板的特化:string类型
template<>
class Box<string>
{
public:
    Box(string value = "hello")
    :_value(value)
    {}

    string getValue() const{
        return _value;   
    }
private:
    string _value;
};


void test(){
    Box<float> b1;
    cout << b1.getValue() << endl;

    Box<char> b2;
    cout << b2.getValue() << endl;
    
    Box<Point> b3;
    b3.getValue().print(); 

    //string插不了Box,需要类模板的特化
    Box<string> b4;
    cout << b4.getValue() << endl;
}

int main()
{
    test();   
    return 0;
}

代码链接：https://github.com/Edward/Object-Oriented/blob/main/template/类模板/classTemplate.cpp



(3)可变参数模板

可变参数模板(variadic templates)是 C++11 新增的最强大的特性之一，它对参数进行了高度泛化，它能表示0到任意个数、任意类型的参数。由于可变参数模板比较抽象，使用起来需要一定的技巧，所以它也是 C++11 中最难理解和掌握的特性之一。

可变参数模板和普通模板的语义是一样的，只是写法上稍有区别，声明可变参数模板时需要在typename 或 class 后面带上省略号 “…”

//可变参数模板
template <class ...Args>  
void func(Args ...args);

//普通函数模板做对比
template <class T1,class T2>
void func(T1 t1, T2 t2);

Args叫做模板参数包，相当于将 T1/T2/T3/…等类型参数打了包
args叫做函数参数包，相当于将 t1/t2/t3/…等函数参数打了包
省略号写在参数包的左边，代表打包


例如，我们在定义一个函数时，可能有很多个不同类型的参数，不适合一一写出，就可以使用可变参数模板的方法。

利用可变参数模板输出参数包中参数的个数：

#include <iostream>
using std::cout;
using std::endl;

template <class ...Args>//Args 模板参数包
void display(Args ...args)//args 函数参数包
{
    //输出模板参数包中类型参数个数
    cout << "sizeof...(Args) = " << sizeof...(Args) << endl;
    //输出函数参数包中参数的个数
    cout << "sizeof...(args) = " << sizeof...(args) << endl;
}

void test0(){
    display();
    display(1,"hello",3.3,true);
    display(1,"hello",3.3,true,'a',2);
}

int main(void){
    test0();
    return 0;
}

在这里插入图片描述


——试验：希望打印出传入的参数的内容

就需要对参数包进行解包。每次解出第一个参数，然后递归调用函数模板，直到递归出口

//递归的出口
void print(){
	cout << endl;
}

//重新定义一个可变参数模板，至少得有一个参数
template <class T,class ...Args>
void print(T x, Args ...args)
{
	cout << x << " ";
	print(args...);  //省略号在参数包右边
}

省略号写在参数包的左边，代表打包
省略号写在参数包的右边，代表解包



3.应用

(1)模板实现快排

#include <math.h>
#include <iostream>
#include <vector>
#include <ostream>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

template<typename T>
void swap(T &lhs,T &rhs)
{
    auto temp = lhs;
    lhs = rhs;
    rhs = temp;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
        // cout << "Point(int = 0, int = 0)" << endl;
    }

    ~Point()
    {
        // cout << "~Point()" << endl;
    }

    void print() const 
    {
        cout << "(" << _ix 
             << ", " << _iy 
             << ")" << endl;
    }

    double getDistance() const
    {
        return hypot(_ix, _iy);
    } 

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;
    }

    friend std::ostream & operator<<(std::ostream &os, const Point &rhs);

private:
    int _ix;
    int _iy;
};

std::ostream & operator<<(std::ostream &os,const Point &rhs)
{
    os << "(" << rhs._ix
       << ", " << rhs._iy
       << ")";

    return os;
}


namespace std
{   
//std命名空间中的less的特化，注意模板的特化
template<>
struct less<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator<(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() < rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() < rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() < rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

struct Comparetion
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

namespace std
{   
//std命名空间中的less的特化，注意模板的特化
template<>
struct greater<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() > rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() > rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() > rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator>(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() > rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() > rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() > rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

template<typename T,typename Compare = std::less<T>>
class MyQsort
{
public:
    MyQsort(T *arr, size_t size, Compare );
    void quick(int left, int right, Compare &);
    int partition(int left, int right, Compare &);
    void print();
private:
    vector<T> _vec;
};
 
template <typename T, typename Compare>
void MyQsort<T,Compare>::print()
{
    for(auto &elem : _vec)
    {
        cout << elem << "  ";
    }
    cout << endl;
}

template<typename T,typename Compare>
MyQsort<T,Compare>::MyQsort(T * arr, size_t size, Compare com)
{
    for(size_t i = 0; i < size; i++)
    {
        _vec.push_back(arr[i]);
    }

    quick(0, _vec.size() - 1, com);
}

template<typename T,typename Compare>
void MyQsort<T,Compare>::quick(int left, int right, Compare &com)
{
    int pivot;
    if(left < right)
    {
        pivot = partition(left, right, com);
        quick(left, pivot - 1, com);//左边递归调用
        quick(pivot + 1, right, com);//右边递归调用
    }
}

template<typename T, typename Compare>
int MyQsort<T, Compare>::partition(int left, int right, Compare &com)
{
    int indexi, indexk;
    for(indexi = left, indexk = left; indexi < right; ++indexi)
    {
        if(com(_vec[indexi], _vec[right]))
        {
            swap(_vec[indexi], _vec[indexk]);
            ++indexk;
        }

    }
    swap(_vec[indexk], _vec[right]);

    return indexk;
}

int main(int argc,char **argv)
{
    int arr[10] = {1, 2, 4, 5, 8, 6, 3, 7, 10, 9} ;
    MyQsort<int> mqInt(arr, 10, std::less<int>());
    /* MyQsort<int, std::greater<int>> mqInt1(arr, 10, std::greater<int>()); */

    mqInt.print();

    Point par[5] = {Point(1,2), Point(3,4), Point(-1,2), Point(4,5), Point(2,5)};
    MyQsort<Point> mqPt(par,5,std::less<Point>());
    mqPt.print();

    return 0;

}

(2)模板实现堆排

#include <math.h>
#include <iostream>
#include <vector>
#include <ostream>

using std::cout;
using std::cin;
using std::endl;
using std::vector;

template<typename T>
void swap(T &lhs, T &rhs)
{
    auto temp = lhs;
    lhs = rhs;
    rhs = temp;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
        //cout << "Point(int = 0,int = 0)" << endl;
    }

    ~Point()
    {
        // cout << "~Point()" << endl;
    }

    void print() const
    {
        cout << "(" << _ix 
            << ", " << _iy 
            << ")" << endl;
    }

    double getDistance() const
    {
        return hypot(_ix, _iy);
    } 

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;

    }

    friend std::ostream & operator<<(std::ostream &os, const Point &rhs);
private:
    int _ix;
    int _iy;
};

std::ostream & operator<<(std::ostream &os,const Point &rhs)
{
    os << "(" << rhs._ix
       << ", " <<rhs._iy
       << ")";
    return os;
}

namespace std
{   
//std命名空间中的less的特化，注意模板的特化
template<>
struct less<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator<(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() < rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() < rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() < rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

//函数对象
struct Comparetion
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

namespace std
{   
//std命名空间中的less的特化，注意模板的特化
template<>
struct greater<Point>
{
    bool operator()(const Point &lhs,const Point &rhs) const
    {
        if(lhs.getDistance() > rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() > rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() > rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};   

}//end of namespace std

bool operator>(const Point &lhs, const Point &rhs)
{
    if(lhs.getDistance() > rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs.getX() > rhs.getX())
        {
            return true;
        }
        else if(lhs.getX() == rhs.getX())
        {
            if(lhs.getY() > rhs.getY())
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

template <typename T, typename Compare = std::less<T>>
class HeapSort
{
public:
    HeapSort(T *arr, size_t size,Compare);
    void heapAdjust(size_t ,size_t ,Compare&);
    void sort(Compare&);
    void print();

private:
    vector<T> vec;
};

template <typename T, typename Compare>
void HeapSort<T,Compare>::print()
{
    for(auto &elem : vec)
    {
        cout<< elem << "  ";
    }
    cout << endl;
}

template <typename T, typename Compare >
void HeapSort<T, Compare>::heapAdjust(size_t adjustpos, size_t arrlen, Compare& com)
{

    size_t dad = adjustpos;
    size_t son= 2 * dad + 1;
    while(son < arrlen)
    {
        if(son + 1 < arrlen && com(vec[son],vec[son + 1]))
        {
            ++son;
        }
        if(com(vec[dad], vec[son]))
        {
            swap(vec[dad], vec[son]);
            dad = son;
            son= 2 * dad + 1;
        }
        else
        {
            break;
        }
    }
}

template <typename T, typename Compare >
HeapSort<T, Compare>::HeapSort(T *arr, size_t size, Compare com)
{
    for (size_t i = 0; i < size; i++)
    {
        vec.push_back(arr[i]);
    }
    for (int i = size/2 - 1; i >= 0; i--)
    {
        heapAdjust(i, size,com);
    }
    swap(arr[0], arr[size - 1]);
    sort(com);

}

template <typename T, typename Compare >
void HeapSort<T, Compare>::sort(Compare& com)
{
    size_t size = vec.size();
    for (size_t i = size; i > 1; i--)
    {
        heapAdjust(0, i, com);
        swap(vec[0], vec[i - 1]);
    }
}

int main(int argc, char **argv)
{
    int arr[10] = {1, 2, 6, 3, 4, 8, 5, 7, 9, 10};
    HeapSort<int> hs(arr, 10, std::less<int>());
    hs.print();
    cout << endl;
    Point par[5] = {{1,2}, {3,4}, {-1,2}, {4,5}, {2,5}};

    HeapSort<Point> hsPt(par, 5, std::less<Point>());
    hsPt.print();

    return 0;
}
标签
#c++ #模板
2026 Dev C++教学配置指南：零基础C语言环境搭建
weixin_34111790的博客
07-15 406
Dev C++并非过时工具，而是面向编程初学者的轻量级集成开发环境（IDE），其核心原理在于极简架构与编译器深度绑定，技术价值体现在零依赖部署、中文界面开箱即用、错误提示直白易懂，特别适用于高校C语言教学、中职计算机基础课及大一实验实训等低门槛入门场景。在Windows系统下，它规避了VS Code配置复杂、MinGW路径混乱、编码乱码频发等典型工程化障碍，成为连接语法概念与可执行结果的可靠认知脚手架。本文聚焦2026年稳定教学版Dev C++ 5.11的实际部署，详解安装路径规范、GBK编码配置、TDM-
魔板问题C++源代码
12-07
这个程序是做程序设计竞赛题时，可以秒杀，对那些初学者有点作用
（B站黑马C++）模板
IT OR 考公？
07-07 2862
记录代码，只用于复习
滚动轴承振动信号特征解析与故障诊断模型构建
最新发布
qsc901234567的博客
03-06 351
本文深入解析了滚动轴承振动信号的三大来源与特征，并详细阐述了从时域、频域到时频域的特征提取方法。通过构建基于机器学习（如随机森林、SVM）或深度学习的故障诊断模型，结合实战代码示例，为设备维护工程师提供了一套从信号分析到智能诊断的完整解决方案，旨在实现精准的故障识别与预测性维护。
C++之模板
m0_74893211的博客
06-22 5429
C++泛型编程和STL技术详细讲解。
C++模板
weixin_63246738的博客
05-19 7120
c++的模板
C++模板详解
qq_52905520的博客
10-21 2万+
C++模板详解
C++——模板（超详细的模板解析）
热门推荐
JAN6055的博客
04-01 5万+
超详细的C++模板知识列表，持续维护。
C++(week10): C++基础 第一章:C++与C
Edward2022的博客
06-27 1203
C++基础：C++与C
C++(week13): C++基础: 标准模板库 STL
Edward2022的博客
07-23 1105
标准模板库STL的6大组件：容器、迭代器、算法、适配器、函数对象(仿函数)、空间配置器
C++(week12): C++基础 第八章:多态
Edward2022的博客
07-15 1070
多态
C++(week10)：C++基础: 第二章 类与对象
Edward2022的博客
07-01 1497
类、对象、构造、析构、拷贝构造、赋值运算符函数、数据成员、成员函数、new、delete、单例模式、string、vector
C/C++语言基础--从C到C++的不同(下），15个部分说明C与C++的不同
羊小猪~~的博客
09-16 2305
上面内容过多，很难记住，我也记不住，
蓝桥杯备赛 week 3 —— 高精度（C/C++，零基础，配图）
jupangMZ的博客
01-17 3766
蓝桥杯备赛 day 3 —— 高精度（C/C++，零基础，配图） 这篇文章主要是准备蓝桥杯竞赛同学所写，为你更好准备蓝桥杯比赛涉及的算法知识点。不知道你是否苦恼于不知算法从何学起，苦恼于网上资料稀少，或者复杂难懂，这篇文章就是帮助这部分同学的。
C/C++语言基础--C++智能指针(unique_ptr、shared_ptr、week_ptr)
羊小猪~~的博客
12-01 1696
智能指针是一个模板类，封装了裸指针，可以对指针进行安全的操作。使用RAII特点，将对象生命周期使用栈来管理智能指针区分了所有权，因此使用责任更为清晰智能指针大量使用操作符重载和函数内联特点，调用成本和裸指针无差别shared_ptr可以用来避免内存泄漏，可以自动释放内存，但是在使用中可能存在循环引用，使引用计数失效，从而导致内存泄漏的情况。();
C++ Primer Week1
wyzhang的BLOG
10-25 1808
The notes of chapter 1, chapter 2 and chapter 3 of C++ Primer 5th edition .
C/C++中struct和class的区别
Serven的博客
05-01 1万+
struct和class的区别
Week9-C++基础4（继承、多态、模板及类型转换的知识学习）
qq_49496972的博客
09-05 223
一、继承 1、引出 例如： 网页上有很多公共部分，如果按照一般的写法导致实现时候有很多重复的代码，因此引出继承的方法来简化代码量。 2、语法 class 子类 :继承方式 父类 3、继承方式 ①公有继承 父类中的protected 在子类中是 protected 父类中的public 在子类中是 public ②保护继承 父类中的protected 在子类中是 protected 父类中的public 在子类中是 protected ③私有继承 父类中的protected 在子类中是 private 父类
C++学习路线
m0_54160580的博客
02-28 1337
│ C++学习总结 ││ ││ 学习C++是一个长期的过程，需要： ││ ││ 1. 扎实基础：语法、OOP、内存管理 ││ 2. 掌握STL：容器、算法、迭代器 ││ 3. 理解现代C++：C++11/14/17/20 ││ 4. 项目实战：通过实际项目巩固知识 ││ 5. 持续学习：关注新标准、阅读优秀代码 ││ ││ 记住：C++是一门既强大又复杂的语言， ││ 不要急于求成，循序渐进才能掌握精髓！││ ││ 祝你学习顺利！││ │。
C++训练营学习大纲
Edward2022的博客
02-18 811
C++完整学习教程目录
C++——基础(指针、字符串、输入输出、结构体、引用、函数、模板)
mankeywang的博客
07-26 1460
1. 基础 1.1 C++区分大小写，拓展名为cpp C++头文件扩展名没有扩展名，有些C的头文件转化为C++头文件，去掉h头文加上前缀c（math.h->cmath） main函数 C++的标准主函数形式 int main() { } C语言标准主函数 int main(void) { } c++标准 # include <iostream> using namespace std; 2.常量 作用：记录不可更改的数据 #define 宏定义：#defi
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

程序员爱德华

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值