C++ Primer Notes(16)

1.实例化：编译器用推断出来的模板参数来为我们实例化一个特定版本的函数，这些编译器生成的版本成为模板的实例；

2.模板类型参数：template<typename/class T>;//T为模板类型参数；

3.非模板类型参数：template<int/char/double....   N>;//N为非类型模板参数，在模板定义内N是一个常量。非类型模板参数的模板实参必须是常量表达式；

4.当编译器遇到一个模板定义时，它并不生成代码。只有当我们实例化出模板的一个特定版本时，编译器才会生成代码。也就是说当我们使用模板时编译器才会生成代码；

5.模板的头文件通常既包括声明也包括定义：调用普通函数时，编译器只需掌握函数的声明，当我们使用一个类类型的对象时，类定义必须是可用的，但成员函数的定义不必已经出现，因此我们可以将类定义和函数声明放在头文件中，函数实现放在源文件中；模板则不同：为了生成一个实例化版本，编译器需要掌握函数模板或类模板成员函数的定义，以此，模板的头文件既包括声明也包括定义（通常）；

6.类模板与函数模板区别：编译器不能为类模板推断模板参数类型，为了使用类模板，必须在模板名后面的尖括号中提供额外信息；

7.类模板的每个实例都形成一个独立的类，都有自己版本的成员函数，因此，类模板的成员函数具有和模板相同的模板类型，所以定义在类模板之外的成员函数必须以关键字开始；

8.在类外定义一个成员时必须说明成员属于哪个类（是类！是一个模板的实例，不是模板，），所以用classA<T>::

9.如果一个成员函数没有被使用，则它不会被实例化，成员函数只有被用到时才会实例化；

10.在类模板自己的作用域中，我们可以直接使用模板名而不用提供实参；我们在类模板外定义成员时，我们并不在类作用域中，直到遇到类名（classA<T>::）才表示进入类的作用域。

11.类模板与友元：当一个类模板包含一个友元声明时，类与友元各自是否具有模板是相互无关的，也就是说友元可以是模板可以是非模板；

• 如果一个类模板包含一个非模板友元，则友元被授权可以访问所有类模板实例。
• 如果一个非模板类包含一个模板友元，则所有友元实例被授权可以访问该类。
• 如果一个类模板与友元模板拥有相同的类型参数，则类与友元为一对一的友好关系。
• 如果一个类模板与友元模板拥有不同的类型参数，则类的每一个实例授权给所有模板实例。

12.类模板的static成员：声明与非模板类一样，定义时必须定义成模板：template<class T> size_t Foo<T>::sta=0;

13：

模板类中操作符重载问题（"<<"和">>"重载）

在模板类中输入流“>>”和输出流“<<”的重载,若使用友元在类内声明，在类外实现，那么连接时将会报错,但我们可以采用以下三种方式来实现输出流"<<"和"输入流>>"的重载。

一、将输出流"<<"和"输入流>>"重载的实现写在类中

#include  " stdafx.h "
#include   <iostream>
using    namespace   std;  
   
template< class T>  
class Test  
{  
    public:  
      Test( const T& t):data(t){}
       // ---------------------------------------------
      friend ostream&  operator<<(ostream&  out,Test<T>& t)     // 输出流重载声明及实现
      {
            return  out<< " data   is    "<<t.data;
      }  // --------------------------------------------
      friend istream&  operator>>(istream&  in,Test<T>& t)       // 输入流重载声明及实现
      {
           return  in>>t.data;
      } // ---------------------------------------------
    private:  
      T data;  
}; // -----------------------------------------------------------------      
      
int   main()  
{  
   Test< int> b( 3);  
   cout<<b<< ' \n ';  
   cin>>b;
   cout<<b<< ' \n ';
    return  0;
}

那么输入输出流重载为什么不能在类内声明，类外实现呢？？因为模板比较特殊，若果在模板类外实现重载的话：

template< class T>
ostream&  operator<<(ostream&  out,Test<T>& t)
{
         return  out<< " data   is    "<<t.data;
}  // --------------------------------------------

上面正好是函数模板的定义,而我们知道操作符重载函数不是类的成员函数，因此此处相当于定义了一个新的函数模板（不同于类中的friend ostream& operator<<(ostream& out,Test<T>& t) ）。但若去掉template<class T> ，函数中的参数Test<T>就不知是什么类型，所以不能在模板类内声明，类外实现操作符重载。

二、既然类外实现相当于重定义了一个函数模板，那么只要他不使用类的私用成员即可，因此重载的函数模板只有通过类的公有成员函数来实现对类的私有成员的操作，这样不必在类内声明它为友元，直接在类外重载即可。

#include  " stdafx.h "
#include   <iostream>
using    namespace   std;  
   
template< class T>  
class Test  
{  
    public:  
      Test( const T& t):data(t){}
      T GetData() const{ return data;}
       void SetData(T &item){data=item;}
    private:  
      T data;  
}; // -----------------------------------------------------------------
template< class T>      
ostream&  operator<<(ostream&  out,Test<T>& t)   
{
       return  out<< " data   is    "<<t.GetData();
}  // --------------------------------------------
template< class T>
istream&  operator>>(istream&  in,Test<T>& t)     
{
     T item;
     in>>item;
    t.SetData(item);
     return  in;
} // ---------------------------------------------      
int   main()  
{  
   Test< int> b( 3);  
   cout<<b<< ' \n ';  
   cin>>b;
   cout<<b<< ' \n ';
    return  0;
} 

三、使用过渡函数

#include  " stdafx.h "
#include   <iostream>
using    namespace   std;  
   
template< class   T>  
class   Test  
{  
    public:  
      Test( const T& t):data(t){}
       // ---------------------------------------------
      template< class CharT, class CharTraits>  
      basic_ostream<CharT,CharTraits>& Output(basic_ostream<CharT,CharTraits>&  out) const     // 输出流过渡函数
      {
             return  out<< " data   is    "<<data;
      }  // --------------------------------------------
      template< class   CharT, class   CharTraits>  
      basic_istream<CharT,CharTraits>& Input(basic_istream<CharT,CharTraits>&  in)     // 输入流过渡函数
      {
           return  in>>data;
      } // ---------------------------------------------
    private:  
      T data;  
}; // -----------------------------------------------------------------      
template< class T, class CharT, class CharTraits>  
basic_ostream<CharT,CharTraits>&  operator<<(basic_ostream<CharT,CharTraits>&  out, const Test<T>& t)    // 输出流重载
{  
     return t.Output( out);  
} // ------------------------------------------------------------------      
template< class T, class CharT, class CharTraits>  
basic_istream<CharT,CharTraits>&  operator>>(basic_istream<CharT,CharTraits>&  in,Test<T>& t)    // 输入流重载
{  
     return t.Input( in);  
} // ------------------------------------------------------------------      
int   main()  
{  
   Test< int>   b( 4);  
   cout<<b<< ' \n ';  
   cin>>b;
   cout<<b<< ' \n ';
    return  0;
}