• C++Primer 16.1定义模板 习题总结

    目录

    16.1.1 函数模板

    练习16.4 模拟实现find标准库函数

    练习16.5 print函数，打印任意元素类型，任意大小的数组。

    练习16.6 模拟接收一个数组实参的begin end标准库函数的实现。

    16.1.2 类模板 

    Blob 类模板和BlobPtr类模板实现

    练习16.14 Screen类模板，用非类型模板参数定义Screen的高和宽

    16.1.3 模板参数 

     默认模板实参： compare函数的进一步定义。

     练习 16.19 16.20

    16.1.4 成员模板

    练习16.21  DebugDelete类实现，普通类的成员模板。 

     16.1.5 控制实例化

    16.1.6  效率与灵活性

    练习16.28

    16.1.1 函数模板

    1. template <typename T>  // 其实就是代表一个类型而已，也没啥。
    2. int compare(const T &v1, const T &v2){
    3.     if(v1 < v2) return -1;
    4.     if(v2 < v1) return 1;
    5.     return 0;
    6. }

    模板实现compare函数，用于任意两种相同类型的比较，前提是，此类型支持<运算符。

    练习16.4 模拟实现find标准库函数

    1. template <typename T1, typename T2>
    2. T1 my_find(const T1& beg,const T1& end,const T2& value){
    3.     for(auto i = beg; i != end; ++i){
    4.         if(*i == value)
    5.             return i;
    6.     }
    7.     return end;
    8. }

    练习16.5 print函数，打印任意元素类型，任意大小的数组。

    1. template <typename T, unsigned int sz> // sz是unsigned类型常量。
    2. void print(const T (&arr)[sz]){
    3.     for(int i = 0; i != sz; ++i){
    4.         cout<<arr[i]<<" ";
    5.     }
    6.     cout<<endl;
    7. }
    8. void test_16_5(){
    9.     int arr1[5] = {1,2,3,4,5};
    10.     print(arr1);
    11.     string arr2[3] = {"aaa","bbb","ccc"};
    12.     print(arr2);
    13. }

    这里用到了非类型模板参数，其中的unsigned int sz就是一个非类型模板参数，可用于模板中需要常量的地方，根据传来的函数实参进行推断此非类型模板参数的模板实参。比如 第一个print中sz = 5，第二个print中sz = 3

    练习16.6 模拟接收一个数组实参的begin end标准库函数的实现。

    1. template <typename T, size_t sz>
    2. T* my_begin(T (&arr)[sz]){
    3.     return &arr[0];
    4. }
    5.  
    6. template <typename T, size_t sz>
    7. T* my_end(T (&arr)[sz]){
    8.     return &arr[0] + sz;
    9. }
    10.  
    11. template <typename T, size_t sz>
    12. const T* my_cbegin(const T (&arr)[sz]){
    13.     const T* ret = &arr[0];
    14.     return ret;
    15. }
    16.  
    17. template <typename T, size_t sz>
    18. const T* my_cend(const T (&arr)[sz]){
    19.     const T* ret = &arr[0] + sz;
    20.     return ret;
    21. }

    16.1.2 类模板 

    Blob 类模板和BlobPtr类模板实现

    1. template <typename> class BlobPtr;
    2. template <typename> class Blob;
    3. template <typename T>
    4.     bool operator==(const Blob<T>&, const Blob<T>&);
    5.  
    6. template <typename T>
    7. class Blob{
    8.     friend class BlobPtr<T>;
    9.     friend bool operator==<T> (const Blob<T>&, const Blob<T>&);
    10. public:
    11.     using size_type = typename vector<T>::size_type;
    12.     template <typename It> Blob(It t1, It t2);
    13. //    : data(make_shared<vector<T>>(t1,t2)) {}
    14.     Blob(): data(make_shared<vector<T>>()) {}
    15.     Blob(initializer_list<T> il):data(make_shared<vector<T>>(il)) {}
    16.     size_type size()const { return data->size(); }
    17.     bool empty()const { return data->empty(); }
    18.     void push_back(const T& ele) { data->push_back(ele); }
    19.     void push_back(T &&ele) { data->push_back(std::move(ele)); }
    20.     void pop_back();
    21.     T& back();
    22.     const T& back()const;
    23.     T& operator[](size_type i);
    24.     const T& operator[](size_type i)const;
    25. private:
    26.     shared_ptr<vector<T>> data;
    27.     void check(size_type i, const string& msg)const;
    28. };
    29. template <typename T> template <typename It> Blob<T>::Blob(It t1, It t2):data(make_shared<vector<T>>(t1,t2)) {}
    30. template <typename T> void Blob<T>::check(size_type i, const string& msg)const{
    31.     if(i>=data->size())
    32.         throw out_of_range(msg);
    33. }
    34.  
    35. template <typename T> void Blob<T>::pop_back(){
    36.     check(0,"pop_back on empty Blob");
    37.     data->pop_back();
    38. }
    39.  
    40. template <typename T>
    41. T& Blob<T>::back(){
    42.     check(0,"back on empty Blob");
    43.     return data->back();
    44. }
    45.  
    46. template <typename T>
    47. const T& Blob<T>::back()const{
    48.     check(0,"beck on empty Blob");
    49.     return data->back();
    50. }
    51.  
    52. template <typename T>
    53. T& Blob<T>::operator[](size_type i){
    54.     check(i,"subscript out of range");
    55.     return (*data)[i];
    56. }
    57.  
    58. template <typename T>
    59. const T& Blob<T>::operator[](size_type i)const{
    60.     check(i,"subscript out of range");
    61.     return (*data)[i];
    62. }
    63.  
    64. template <typename T>
    65. class BlobPtr
    66. {
    67. public:
    68.     BlobPtr(): curr(0) {}
    69.     BlobPtr(Blob<T>& a, size_t sz = 0): wptr(a.data), curr(sz) {}  // 仅一个Blob对象作为参数，curr默认为0;
    70.     T& operator*() const{
    71.         auto p = check(curr, "dereference past end");
    72.         return (*p)[curr];
    73.     }
    74.     // prefix
    75.     BlobPtr& operator++();
    76.     BlobPtr& operator--();
    77.     // postfix
    78.     BlobPtr operator ++(int);
    79.     BlobPtr operator --(int);
    80. private:
    81.     // returns a shared_ptr to the vector if the check succeeds;
    82.     shared_ptr<vector<T>> check(size_t, const string& msg)const;
    83.     weak_ptr<vector<T>> wptr;
    84.     size_t curr;
    85. };
    86.  
    87. template <typename T>
    88. shared_ptr<vector<T>> BlobPtr<T>::check(size_t index, const string& msg)const{
    89.     auto p = wptr.lock();
    90.     if (p) {
    91.         if (p->size() > index) {
    92.             return p;
    93.         } else {
    94.             throw std::out_of_range(msg);
    95.         }
    96.     } else {
    97.         throw "unbind BlobPtr";
    98.     }
    99. }
    100.  
    101. // prefix ++
    102. template <typename T> BlobPtr<T>& BlobPtr<T>::operator++(){
    103.     check(curr, "increment past end of StrBlob");
    104.     ++curr;
    105.     return *this;
    106. }
    107. template <typename T> BlobPtr<T>& BlobPtr<T>::operator--(){
    108.     --curr;
    109.     check(-1, "decrease index pass the beg");
    110.     return *this;
    111. }
    112.  
    113. template <typename T> BlobPtr<T> BlobPtr<T>::operator++(int){
    114.     BlobPtr ret = *this;
    115.     ++*this;  // 利用前置加加检验递增是否合法
    116.     return ret;
    117. }
    118.  
    119. template <typename T> BlobPtr<T> BlobPtr<T>::operator--(int){
    120.     BlobPtr ret = *this;
    121.     --*this;
    122.     return ret;
    123. }

    Blob类模板，就是很简单的一个类模板的练习，模拟vector，根据模板实参确定保存的元素类型。剩余的就是一些定义，声明的规则了。还有，比如使用类模板的类型成员，需要声明typename，类模板的模板成员，如Blob类的接收两个迭代器参数的构造函数，就是一个函数模板，定义时，类模板的模板参数列表和函数模板的模板参数列表都需要声明。以及BlobPtr类定义时，在参数的作用域范围内，返回值BlobPtr可以省略模板实参，这都是一些小的规则而已。

    练习16.14 Screen类模板，用非类型模板参数定义Screen的高和宽

    1. #ifndef C__PRIMER_SCREEN_16_14_H
    2. #define C__PRIMER_SCREEN_16_14_H
    3.  
    4. #include<iostream>
    5. #include<string>
    6. using namespace std;
    7. template<int H,int W> class Screen; // 声明这个，下面的<<>>声明才可以
    8. template<int H,int W> ostream& operator<<(ostream& os, const Screen<H,W>&);
    9. template<int H,int W> istream& operator>>(istream& is, Screen<H,W>&);
    10. template <int H, int W>
    11. class Screen{
    12.     friend ostream& operator<< <H,W>(ostream&,const Screen<H,W>&);
    13.     friend istream& operator>> <H,W>(istream&,Screen<H,W>&);
    14. public:
    15.     Screen() : contents(W*H,' ') {}
    16.     Screen(char c):contents(W*H, c) {}
    17.     char get()const { return contents[cursor]; }  // 隐式内联
    18.     inline char get(int, int)const;    // 显式内联
    19.     Screen& clear(char c = bkground);
    20. private:
    21.     static const char bkground = ' ';
    22. public:
    23.     Screen& move(int,int);
    24.     Screen& set(char);
    25.     Screen& set(int,int,char);
    26.     Screen& display(ostream& os)
    27.         { do_display(os); return *this; }
    28.     const Screen& display(ostream& os)const
    29.         { do_display(os); return *this;}
    30. private:
    31.     //实际完成显式的函数
    32.     void do_display(ostream& os)const {os<<contents;}
    33.     int cursor = 0;
    34.     string contents;
    35. };
    36. template <int H, int W> inline char Screen<H,W>::get(int r,int c)const{
    37.     return contents[r*W+c];
    38. }
    39. template<int H,int W> Screen<H,W>& Screen<H,W>::clear(char c){
    40.     contents = string(H*W,c);
    41.     return *this;
    42. }
    43. template <int H,int W> inline Screen<H,W>& Screen<H,W>::move(int r,int c){
    44.     cursor = r*W+c;
    45.     return *this;
    46. }
    47.  
    48. template<int H, int W>
    49. Screen<H,W>& Screen<H, W>::set(char c){
    50.     contents[cursor] = c;
    51.     return *this;
    52. }
    53. template<int H,int W>
    54. Screen<H,W>& Screen<H,W>::set(int r,int col,char ch){
    55.     contents[r*W+col] = ch;
    56.     return *this;
    57. }
    58.  
    59. template<int H,int W> ostream& operator<<(ostream& os, const Screen<H,W>& s){
    60.     os<<s.contents;
    61.     return os;
    62. }
    63.  
    64. template<int H,int W> istream& operator>>(istream& is, Screen<H,W>& s){
    65.     string t;
    66.     cin >> t;
    67.     s.contents = t.substr(0,H*W);
    68.     return is;
    69. }
    70.  
    71. #endif //C__PRIMER_SCREEN_16_14_H

     用非类型模板实参确定Screen的高和宽，而不是之前的把高和宽定义为私有数据成员。也是一个练习而已。注意<< >> 运算符重载函数，仍然需要模板，且友元声明时，   

    friend ostream& operator<< <H,W>(ostream&,const Screen<H,W>&);
    friend istream& operator>> <H,W>(istream&,Screen<H,W>&);

    需要加上<H,W>。还有类模板的声明，以及函数声明。

    16.1.3 模板参数 

     默认模板实参： compare函数的进一步定义。

    1. template < typename T, typename F = less<T> >
    2. int compare(const T& v1, const T& v2, F f = F()){
    3.     if(f(v1,v2))
    4.         return -1;
    5.     if(f(v2,v1))
    6.         return 1;
    7.     return 0;
    8. }

     练习 16.19 16.20

    1. // 16.19
    2. template <typename T>
    3. void print(const T& v){
    4.     for(typename T::size_type sz = 0; sz!=v.size();++sz) {
    5.         cout << v[sz] << " ";
    6.     }
    7. }
    8.  
    9. template <typename T>
    10. void print_2(const T& v){
    11.     for(auto i = v.begin(); i != v.end(); ++i){
    12.         cout<<*i<<" ";
    13.     }
    14.     cout<<endl;
    15. }

     使用类的类型成员

    16.1.4 成员模板

    练习16.21  DebugDelete类实现，普通类的成员模板。 

    1. // 16.1.4
    2. class DebugDelete
    3. {
    4. public:
    5.     explicit DebugDelete(ostream& o = cerr): os(o) {}
    6.     template <typename T> void operator() (T* p)const { cout<<"deleting unique_ptr"<<endl; delete p;}
    7. private:
    8.     ostream& os;
    9. };
    10.  
    11. void test_16_21(){
    12.     int* pi = new int(10);
    13.     DebugDelete d;
    14.     d(pi);
    15.     string* ps = new string("hahaha");
    16.     DebugDelete()(ps);
    17. }

     16.1.5 控制实例化

     ........

    16.1.6  效率与灵活性

    练习16.28  shared_ptr unique_ptr简单实现

    1. // 16.1.6 效率与灵活性   test16_28
    2. template <typename T>
    3. class Shared_p{
    4. public:
    5.     Shared_p():p(nullptr), use(nullptr){}
    6.     // shared_p<int> p(new int(1));
    7.     explicit Shared_p(T* pt):p(pt), use(new size_t(1)) {}
    8.     Shared_p(const Shared_p& sp): p(sp.p),use(sp.use){
    9.         if(use) ++*use;
    10.     }
    11.     Shared_p& operator=(const Shared_p& sp);
    12.     ~Shared_p();
    13.     T& operator*() { return *p; }
    14.     T& operator*()const { return *p; }
    15. private:
    16.     T* p;
    17.     size_t* use;
    18. };
    19.  
    20. template<typename T> Shared_p<T>& Shared_p<T>::operator=(const Shared_p& rhs){
    21.     if(rhs.use)
    22.         ++*use;
    23.     if(use && --*use == 0) {
    24.         delete p;
    25.         delete use;
    26.     }
    27.     p = rhs.p;
    28.     use = rhs.use;
    29.     return *this;
    30. }
    31.  
    32. template<typename T> Shared_p<T>::~Shared_p(){
    33.     if(use && --*use == 0){
    34.         delete use;
    35.         delete p;
    36.     }
    37. }
    38. template <typename T, class... Args>
    39. Shared_p<T> make_shared(Args&&... args){
    40.     return Shared_p<T>(new T(forward<Args>(args)...));
    41. }
    42.  
    43. template <typename T>
    44. class UP
    45. {
    46. public:
    47.     UP():p(nullptr){}
    48.     explicit UP(T* pt):p(pt){}
    49.     UP(const UP&) = delete;
    50.     UP& operator=(const UP&)=delete;
    51.     ~UP(){
    52.         if(p)
    53.             delete p;
    54.     }
    55.     T* release(){
    56.         T* ret = p;
    57.         p = nullptr;
    58.         return ret;
    59.     }
    60.     T* reset(T* new_p = nullptr){
    61.         if(p)
    62.             delete p;
    63.         p = new_p;
    64.     }
    65.     T& operator*() { return *p; }
    66.     T* operator*()const { return *p; }
    67. private:
    68.     T* p;
    69. };

  • 相关阅读:
    Linux 目录结构介绍
    Python爬虫入狱小技巧
    基于PHP+MySQL菜品食谱美食网站的设计与实现
    nacos配置中心
    用路由器远程维护三菱PLC操作指南
    每日一道算法题
    初识设计模式之单例模式
    Spring Boot之容器功能
    科技云报道：Citrix正式退出中国市场！国产们谁能真正顶上？
    Unity之Hololens开发如何实现UI交互
  • 原文地址：https://blog.csdn.net/i777777777777777/article/details/125404423