C++ Primer Plus 学习笔记成员模板模板用作参数模板友元模板别名

阳光穿透心脏的1/2处 2022-01-22 00:17 219阅读 0赞

意思就是类模板中吧类模板当做成员函数或者类成员

直接上代码吧

#include <iostream>
    using std::cout;
    using std::cin;
    using std::endl;
    template<typename T>
    class beta
    {
      private:
        template <typename V>
        class hold
        {
          private:
            V val;
          public:
            shold(V v = 0) : val(v) {}
            void show() const {cout << val << endl;}
            V Value() const {return val;}
        };
        hold<T> q;
        hold<int> n;
      public:
        beta(T t, int i) : q(t), n(i) {}
        template<typename U>
        U blab(U u, T t){return (n.Value() + q.Value()) * u /t;}
        void Show() const { q.show(); n.show();}
    };
    
    int main()
    {
      beta<double> guy(3.5, 3);
      cout << "T was set to double\n";
      guy.Show();
      cout << "V was set to T, which is double, then V was set to int\n";
      cout << guy.blab(10, 2.3) << endl;
      cout << "U was set to int\n";
      cout << guy.blab(10.0, 2.3) << endl;
      cout << "U was set to double\n";
      cout << "Done\n";
      return 0;
    }

C++允许外部定义成员模板。但不是所有的编译器都支持。 如果不支持的话就算了 支持的话可以这么写：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70][]

![20190604163126901.png][]

将模板用于参数：

先上代码在说话

stacktp.h

#ifndef STACKTP_H_
    #define STACKTP_H_
    
    template<class Type>
    class Stack
    {
      private:
        enum {MAX = 10};
        Type items[MAX];
        int top;
      public:
        Stack();
        bool isempty();
        bool isfull();
        bool push(const Type & item);
        bool pop(Type & item);
    };
    
    template<class Type>
    Stack<Type>::Stack()
    {
      top = 0;
    }
    
    template<class Type>
    bool Stack<Type>::isempty()
    {
      return top == 0;
    }
    
    template<class Type>
    bool Stack<Type>::isfull()
    {
      return top == MAX;
    }
    
    template<class Type>
    bool Stack<Type>::push(const Type & item)
    {
      if (top < MAX)
      {
        items[top++] = item;
        return true;
      }
      else
      {
        return false;
      }
    }
    
    template<class Type>
    bool Stack<Type>::pop(Type & item)
    {
      if (top > 0)
      {
        item = items[--top];
        return true;
      }
      else
        return false;
    }
    
    #endif

tempparm.cpp

#include <iostream>
    #include "stacktp.h"
    
    template <template <typename T> class Thing>
    class Crab
    {
      private:
        Thing<int> s1;
        Thing<double> s2;
      public:
        Crab() {};
        bool push(int a, double x) {return s1.push(a) && s2.push(x);}
        bool pop(int & a, double & x) {return s1.pop(a) && s2.pop(x);}
    };
    
    int main() {
      using std::cout;
      using std::cin;
      using std::endl;
    // 这时候 Thing形参就是 模板Stack类型 在默认构造函数的时候就生成int型的Stack模板和double型的Stack模板
      Crab<Stack> nebula;
      int ni;
      double nb;
      cout << "Enter int double pairs, such as 4 3.5 (0 0 to end):\n";
      while(cin >> ni >> nb && ni > 0 && nb > 0)
      {
        if (!nebula.push(ni, nb))
          break;
      }
      while (nebula.pop(ni, nb))
        cout << ni << ", " <<nb << endl;
      cout << "Done.\n";
      
      return 0;
    }

运行结果：

![20190606101005778.png][]

![20190606101659380.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1][]

模板类和友元：

模板类可以有友元， 但是有3种友元

1. 非模板友元

2. 约束模板友元

3.非约束模板友元

一个一个来

非模板友元

template <class T>
    class A
    {
        public:
            friend void counts();
    }

counts()是模板所有实例化对象的友元。 这是不带参数的例子。它可以访问全局对象，可以使用全局指针访问的费全局对象。可以创建自己的对象。 可以访问独立于对象的模板类的静态数据成员。

那如果要带参数呢  而且是要带模板类参数呢？

但需要指明特定类型的对象 比如：

template <class T>
    class A
    {
        public:
            friend void counts(A<T> &);
    }

这样将counts将称为A<T>类的友元。

程序示例：

#include <iostream>
    using std::cout;
    using std::endl;
    
    template <typename T>
    class HasFriend
    {
      private:
        T item;
        static int ct;
      public:
        HasFriend(const T & i) : item(i) {ct++;}
        ~HasFriend() {ct--;}
        friend void counts();
        friend void reports(HasFriend<T> &);
    };
    
    template<typename T>
    int HasFriend<T>::ct = 0;
    
    void counts()
    {
      cout << "int count: " << HasFriend<int>::ct << "; ";
      cout << "double count: " << HasFriend<double>::ct << endl;
    }
    
    void reports(HasFriend<int> & hf)
    {
      cout << "HasFriend<int>: " << hf.item << endl;
    }
    
    void reports(HasFriend<double> & hf)
    {
      cout << "HasFriend<double>: " << hf.item << endl;
    }
    
    int main()
    {
      cout << "No objects delared: ";
      counts();
      HasFriend<int> hfi1(10);
      cout << "After hfil declared: ";
      counts();
      HasFriend<int> hfi2(20);
      cout << "After hfi2 declared: ";
      counts();
      HasFriend<double> hfdb(10.5);
      cout << "AFter hfdb delared: ";
      counts();
      reports(hfi1);
      reports(hfi2);
      reports(hfdb);
    
      return 0;
    }

运行结果

![20190606104403365.png][]

2.约束模板友元函数

就是把友元函数先声明为函数模板 然后在类模板中定义的是该函数模板

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2][]

程序示例：

#include <iostream>
    using std::cout;
    using std::endl;
    
    template<typename T> void counts();
    template<typename T> void report(T &);
    
    template <typename TT>
    class HasFriendT
    {
      private:
        TT item;
        static int ct;
      public:
        HasFriendT(const TT & i) : item(i) {ct++;}
        ~HasFriendT() {ct--;}
        friend void counts<TT>();
        friend void report<>(HasFriendT<TT> &);
    };
    
    template<typename T>
    int HasFriendT<T>::ct = 0;
    
    template<typename T>
    void counts()
    {
      cout << "template size: " << sizeof(HasFriendT<T>) << "; ";
      cout << "template counts(); " << HasFriendT<T>::ct << endl;
    }
    
    template <typename T>
    void report(T & hf)
    {
      cout << hf.item << endl;
    }
    
    int main()
    {
      counts<int>();
      HasFriendT<int> hfi1(10);
      HasFriendT<int> hfi2(20);
      HasFriendT<double> hfdb(10.5);
      report(hfi1);
      report(hfi2);
      report(hfdb);
      cout << "counts<int>() output:\n";
      counts<int>();
      cout << "counts<double>() output:\n";
      counts<double>();
    
      return 0;
    }

运行结果

![20190606112109658.png][]

3.非约束模板友元函数

模板类型放开 ，不用跟着模板类型走：

示例:

#include <iostream>
    using std::cout;
    using std::cin;
    
    template <typename T>
    class ManyFriend
    {
      private:
        T item;
      public:
        ManyFriend(const T & i) : item(i) {}
        template<typename C, typename D> friend void show2(C &, D &);
    };
    
    template<typename C, typename D> void show2(C & c, D & d)
    {
      cout << c.item << ", " << d.item << '\n';
    }
    
    int main()
    {
      ManyFriend<int> hfi1(10);
      ManyFriend<int> hfi2(20);
      ManyFriend<double> hfdb(10.5);
      cout << "hfi1, hfi2: ";
      show2(hfi1, hfi2);
      cout << "hfdb, hfi2: ";
      show2(hfdb, hfi2);
    
      return 0;
    }

运行结果

![20190606135825564.png][]

大体区别就是

非模板的友元： 没有跟着哪个类 就是跟某个实例对象友元。

约束模板函数： 就是跟某个类型的模板关联。

非约束模板函数： 不限制某个类型的模板， 因为定义了另外的两个模板参数。所以可以传入不同类型的模板作为参数。

然后目前来说。好像没啥卵用。

模板别名：

可以这样定义别名：

typedef std::array<int, 12> arri;

C++11 可以这样：

template<typename T>

using arrtype = std::array<T, 12>;

然后可以这么干：

arrtype<double> gallons;

arrtype<int> days;   == array<int , 12>

这种定义别名的方式也适用于非模板

![20190606140841831.png][]

优点： 可读性更强，因为它让类型名和类型信息更清晰。

总结：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 3][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 6][]

第十四章 真 •  完结

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70]: /images/20220122/79fbcfd0335a4b4bb638359976381b58.png
[20190604163126901.png]: /images/20220122/c9a83ad1eeb0451a866c9535b62c7c32.png
[20190606101005778.png]: /images/20220122/95842016a3034859bef774268b7ed3e2.png
[20190606101659380.png]: /images/20220122/f111cb23c9f6429cb7cccb56e0e24113.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 1]: /images/20220122/56d96bf811c9437c9fe2fad6d302ae48.png
[20190606104403365.png]: /images/20220122/933de8cea0874cd6a9e0b3c581cc1f62.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 2]: /images/20220122/582548cc1a284730b2b953fe77614290.png
[20190606112109658.png]: /images/20220122/3a9908068807467ebb60fc61ee55dabe.png
[20190606135825564.png]: /images/20220122/278ec6889bcc4541adb90ece6ca1efcf.png
[20190606140841831.png]: /images/20220122/ed264effcca14741b959a0cc903ca107.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 3]: /images/20220122/725d7fad78134fdb80cd55e7aa728a09.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 4]: /images/20220122/945e2e154e214936822163019cd40574.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 5]: /images/20220122/cb38d23cfa5d423a96cbd108589b62a7.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3NvdWx3eWI_size_16_color_FFFFFF_t_70 6]: /images/20220122/52c199cda6fa442bb527f360226c894b.png