AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

[C++随想录] 模版进阶（下）

2023-10-18 54
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： [C++随想录] 模版进阶（下）

类模板的特化

函数模版的特化 可以用 函数重载 代替, 难道类模版的特化 也可以用 类的重载 来代替?

打你一耳光哦, 你听过类的重载吗~~

当然不行的啦

类模板的特化分为两种, 全特化 和 偏特化

1. 全特化

全特化, 顾名思义, 是 对类模板中的所有参数都 确定化

template<class T1, class T2>
class Date
{
public:
  Date()
  {
    cout << "Date<class T1, class T2> " << endl;
  }
};
// 类模板的全特化
template<>
class Date<int, double>
{
public:
  Date()
  {
    cout << "Date<int, doule>" << endl;
  }
};
int main()
{
  Date<int, int> d1;
  Date<int, double> d2;
  return 0;
}

运行结果:

Date<class T1, class T2>
Date<int, doule>

妙用:👇👇👇

// 优先级队列, 默认是大堆
namespace muyu
{
  template <class T, class Continer = std::vector<T>, class Compare = Less<T> >
  class priority_queue
  {
  private:
    void AjustUp(int child)
    {
      Compare com;
      int parent = (child - 1) / 2;
      while (child > 0)
      {
        if( com(_con[parent], _con[child]) )
        {
          std::swap(_con[child], _con[parent]);
          // 在内部更新child 和 parent
          child = parent;
          parent = (child - 1) / 2;
        }
        else
        {
          break;
        }
      }
    }
    void AjustDown(int parent)
    {
      Compare com;
      int child = 2 * parent + 1;
      while (child < _con.size())
      {
        // 找到孩子中大的那一个
        if (child + 1 < _con.size() &&  com(_con[child], _con[child + 1]) )
        {
          child++;
        }
        if ( com(_con[parent], _con[child]))
        {
          std::swap(_con[parent], _con[child]);
          parent = child;
          child = parent * 2 + 1;
        }
        else
        {
          break;
        }
      }
    }
  public:
    priority_queue()
    {
    }
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last)
    {
      // 一股脑地倒进来
      while (first != last)
      {
        _con.push_back(*first);
        ++first;
      }
      // 建堆
      for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
      {
        AjustDown(i);
      }
    }
    void push(const T& val = T())
    {
      _con.push_back(val);
      AjustUp(_con.size() - 1);
    }
    void pop()
    {
      std::swap(_con[0], _con[_con.size() - 1]);
      _con.pop_back();
      AjustDown(0);
    }
    const T& top() const
    {
      return _con[0];
    }
    bool empty() const
    {
      return _con.size() == 0;
    }
    size_t size() const
    {
      return _con.size();
    }
  private:
    Continer _con;
  };
}
// 日期类
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
  bool operator<(const Date& d)const
  {
    return (_year < d._year) ||
      (_year == d._year && _month < d._month) ||
      (_year == d._year && _month == d._month && _day < d._day);
  }
  bool operator>(const Date& d)const
  {
    return (_year > d._year) ||
      (_year == d._year && _month > d._month) ||
      (_year == d._year && _month == d._month && _day > d._day);
  }
  friend ostream& operator<<(ostream& _cout, const Date& d);
private:
  int _year;
  int _month;
  int _day;
};
// 日期类重载留插入
ostream& operator<<(ostream& _cout, const Date& d)
{
  _cout << d._year << "-" << d._month << "-" << d._day;
  return _cout;
}
// 仿函数
template <class T>
class Less
{
public:
  bool operator()(const T& x, const T& y)
  {
    return x < y;
  }
};
// 全特化
template <>
class Less<Date*>
{
public:
  bool operator()(const Date* x, const Date* y)
  {
    return *x < *y;
  }
};
void test()
{
  muyu::priority_queue<Date*> pq;
  pq.push(new Date(2023, 9, 27));
  pq.push(new Date(2023, 9, 28));
  pq.push(new Date(2023, 9, 29));
  pq.push(new Date(2023, 9, 1));
  while (!pq.empty())
  {
    cout << *pq.top() << " ";
    pq.pop();
  }
  cout << endl;
}
int main()
{
  test();
  return 0;
}

运行结果:

2023-9-29 2023-9-28 2023-9-27 2023-9-1

这样的好处:


传参类型如果是 T, 那么就按照 T 来进行比较; 如果传参类型是 Date*, 那么就按照 Date 来进行比较

其实没有 模版的特化, 我们无法同时写出 T 和 Date* 的一个仿函数.

2.偏特化

偏特化又有两种形式: 部分特化 和 对参数做进一步限制


部分特化

template<class T1, class T2>
class Date
{
public:
  Date()
  {
    cout << "Date<class T1, class T2> " << endl;
  }
};
// 类模板的偏特化
template<class T1>
class Date<T1, double>
{
public:
  Date()
  {
    cout << "Date<T1, double>" << endl;
  }
};
// 类模板的偏特化
template<class T1>
class Date<T1, int&>
{
public:
  Date()
  {
    cout << "Date<T1, int&>" << endl;
  }
};
int main()
{
  Date<int, int> d1;
  Date<int, double> d2;
  Date<int, int&> d3;
  return 0;
}

运行结果:

Date<class T1, class T2>
Date<T1, double>
Date<T1, int&>
  1. 对参数做进一步限制
template<class T1, class T2>
class Date
{
public:
  Date()
  {
    cout << "Date<class T1, class T2> " << endl;
  }
};
// 类模板的偏特化
template<class T1, class T2>
class Date<T1*, T2*>
{
public:
  Date()
  {
    cout << "Date<T1*, T2*>" << endl;
  }
};
// 类模板的偏特化
template<class T1, class T2>
class Date<T1&, T2&>
{
public:
  Date()
  {
    cout << "Date<T1&, T2&>" << endl;
  }
};
int main()
{
  Date<int, int> d1;
  Date<int*, double*> d2;
  Date<int& , int&> d3;
  return 0;
}

运行结果:

Date<class T1, class T2>
Date<T1*, T2*>
Date<T1&, T2&>

那么, 我们可以把所有 有关迭代器的比较 特化成 迭代器指向内容的比较, 从而达到我们比较的目的

// 优先级队列, 默认是大堆
namespace muyu
{
  template <class T, class Continer = std::vector<T>, class Compare = Less<T> >
  class priority_queue
  {
  private:
    void AjustUp(int child)
    {
      Compare com;
      int parent = (child - 1) / 2;
      while (child > 0)
      {
        if( com(_con[parent], _con[child]) )
        {
          std::swap(_con[child], _con[parent]);
          // 在内部更新child 和 parent
          child = parent;
          parent = (child - 1) / 2;
        }
        else
        {
          break;
        }
      }
    }
    void AjustDown(int parent)
    {
      Compare com;
      int child = 2 * parent + 1;
      while (child < _con.size())
      {
        // 找到孩子中大的那一个
        if (child + 1 < _con.size() &&  com(_con[child], _con[child + 1]) )
        {
          child++;
        }
        if ( com(_con[parent], _con[child]))
        {
          std::swap(_con[parent], _con[child]);
          parent = child;
          child = parent * 2 + 1;
        }
        else
        {
          break;
        }
      }
    }
  public:
    priority_queue()
    {
    }
    template<class InputIterator>
    priority_queue(InputIterator first, InputIterator last)
    {
      // 一股脑地倒进来
      while (first != last)
      {
        _con.push_back(*first);
        ++first;
      }
      // 建堆
      for (int i = (_con.size() - 1 - 1) / 2; i >= 0; i--)
      {
        AjustDown(i);
      }
    }
    void push(const T& val = T())
    {
      _con.push_back(val);
      AjustUp(_con.size() - 1);
    }
    void pop()
    {
      std::swap(_con[0], _con[_con.size() - 1]);
      _con.pop_back();
      AjustDown(0);
    }
    const T& top() const
    {
      return _con[0];
    }
    bool empty() const
    {
      return _con.size() == 0;
    }
    size_t size() const
    {
      return _con.size();
    }
  private:
    Continer _con;
  };
}
// 日期类
class Date
{
public:
  Date(int year = 1900, int month = 1, int day = 1)
    : _year(year)
    , _month(month)
    , _day(day)
  {}
  bool operator<(const Date& d)const
  {
    return (_year < d._year) ||
      (_year == d._year && _month < d._month) ||
      (_year == d._year && _month == d._month && _day < d._day);
  }
  bool operator>(const Date& d)const
  {
    return (_year > d._year) ||
      (_year == d._year && _month > d._month) ||
      (_year == d._year && _month == d._month && _day > d._day);
  }
  friend ostream& operator<<(ostream& _cout, const Date& d);
private:
  int _year;
  int _month;
  int _day;
};
// 日期类重载留插入
ostream& operator<<(ostream& _cout, const Date& d)
{
  _cout << d._year << "-" << d._month << "-" << d._day;
  return _cout;
}
// 仿函数
template <class T>
class Less
{
public:
  bool operator()(const T& x, const T& y)
  {
    return x < y;
  }
};
// 偏特化
template <class T>
class Less<T*>
{
public:
  bool operator()(const T* x, const T* y)
  {
    return *x < *y;
  }
};
void test()
{
  muyu::priority_queue<Date*> pq;
  pq.push(new Date(2023, 9, 27));
  pq.push(new Date(2023, 9, 28));
  pq.push(new Date(2023, 9, 29));
  pq.push(new Date(2023, 9, 1));
  while (!pq.empty())
  {
    cout << *pq.top() << " ";
    pq.pop();
  }
  cout << endl;
}
int main()
{
  test();
  return 0;
}
模版的特化总结:
模版的特化离不开原模版, 不能独立存在
特化是做特殊化处理, 具体情况具体使用


文章标签：
C++
关键词：
C++模版
C++进阶
C++模版进阶
游客wvcag6vqpqfh4
目录
相关文章
禁默
|
4月前
|
Unix 编译器 Linux
C++之模版进阶篇（下）
C++之模版进阶篇（下）
禁默
53 0
禁默
|
4月前
|
编译器 C++
C++之模版进阶篇（上）
C++之模版进阶篇（上）
禁默
26 0
禁默
|
4月前
|
编译器 C语言 C++
C++之模版初阶
C++之模版初阶
禁默
22 0
努力学习的小廉
|
4月前
|
存储 编译器 C++
【C++模版初阶】——我与C++的不解之缘（七）
【C++模版初阶】——我与C++的不解之缘（七）
努力学习的小廉
46 0
风掣长空
|
8月前
|
编译器 C++
C++模板进阶
C++模板进阶
风掣长空
36 1
Eternity._
|
8月前
|
存储 算法 程序员
【C++进阶】深入STL之 栈与队列：数据结构探索之旅
【C++进阶】深入STL之 栈与队列：数据结构探索之旅
Eternity._
73 4
Eternity._
|
8月前
|
算法 安全 编译器
【C++进阶】模板进阶与仿函数：C++编程中的泛型与函数式编程思想
【C++进阶】模板进阶与仿函数：C++编程中的泛型与函数式编程思想
Eternity._
71 1
Eternity._
|
8月前
|
存储 算法 程序员
【C++进阶】深入STL之vector：构建高效C++程序的基石
【C++进阶】深入STL之vector：构建高效C++程序的基石
Eternity._
87 1
Eternity._
|
8月前
|
编译器 C++
【C++进阶】深入STL之string：模拟实现走进C++字符串的世界
【C++进阶】深入STL之string：模拟实现走进C++字符串的世界
Eternity._
50 1
Eternity._
|
8月前
|
存储 缓存 编译器
【C++进阶】深入STL之list：模拟实现深入理解List与迭代器
【C++进阶】深入STL之list：模拟实现深入理解List与迭代器
Eternity._
59 0

热门文章

最新文章

  • 1
    【C++数据结构——栈与队列】顺序栈的基本运算（头歌实践教学平台习题）【合集】
  • 2
    【C++数据结构——查找】二分查找（头歌实践教学平台习题）【合集】
  • 3
    【C++面向对象——类与对象】Computer类（头歌实践教学平台习题）【合集】
  • 4
    【C++数据结构——树】哈夫曼树（头歌实践教学平台习题） 【合集】
  • 5
    C++学习之继承
  • 6
    【C++数据结构——图】最短路径（头歌教学实验平台习题） 【合集】
  • 7
    【C++数据结构——内排序】希尔排序（头歌实践教学平台习题）【合集】
  • 8
    【C++数据结构——查找】二叉排序树（头歌实践教学平台习题）【合集】
  • 9
    探秘：基于 C++ 的局域网电脑控制软件自适应指令分发算法
  • 10
    【C++面向对象——继承与派生】派生类的应用（头歌实践教学平台习题）【合集】
  • 1
    c++引用是什么意思？
    66
  • 2
    c++引用看这个就够了
    50
  • 3
    C++ 多态 虚函数和纯虚函数
    68
  • 4
    C++ 重载运算符和重载函数
    63
  • 5
    C++ 类构造函数 & 析构函数
    63
  • 6
    C++ this 指针详解
    66
  • 7
    C++友元函数和友元类
    63
  • 8
    从C++看编程语言发展脉络
    138
  • 9
    LabVIEW使用Python MathWorks® MATLAB®软件和C/C++
    101
  • 10
    LabVIEW传递接收C/C++DLL指针
    238

    • 相关课程

    更多
  • C++ 入门教程开发文档
  • JavaScript 自学手册文档教程
  • PHP进阶教程 - 由浅入深掌握面向对象开发 - 第二阶段
  • 「大师课」搞定 Java 开发基础
  • 高级应用技能进阶
  • Go语言完全自学手册图文教程

    • 相关电子书

    更多
  • 使用C++11开发PHP7扩展
  • GPON Class C++ SFP O;T Transce
  • GPON Class C++ SFP OLT Transce
    • 下一篇
    DeepSeek-V2.5-1210 在线开放使用！支持联网搜索，在各大领域的表现得到全面提升