類模板（原創(chuàng)） - c++探索 - C++博客

jijo 2009-07-06

展開全文

這幾天看了下模板，以下是個人的些心得，高手見笑了

1.類模版 實例 對象定義 引起 實例化
                            指針，引用 不會引起實例化
類非型參數(shù)  只能是 整形，枚舉，外聯(lián)結，且應為一個常量編譯時就應確定
                    浮點型，類類型，。。。都不可以
2.class templates 的成員函數(shù) 在調(diào)用和取地址時實例化，在類實例化時不會自動實例化
3.class templates 的友元申明
    a.非模版類型
          friend class man;
          friend void f(void);
           friend void man::f(void);
   b.一對一的模版友元
             friend class man<T>;
             friend void f<T>( man<T>);
             friend void man<T>::f();
    c.一對多的模版友元
          template <typename T>
               friend class man;
           template <typename T>
              friend void  f( T);
           template <typename T>
              friend void man<T>::f();
4.類模版的靜態(tài)成員 
      并不在模版定義時實例化，在類模版實例化時實例化，對應1個類型
template <typename T>
int man<T>::size=10;
而成員函數(shù)應為
  template <typename T>
   void man<T>::f(void)
{
..........................................
}
5.成員模版 可以是普通類和 模版類
如：
class woman                                             
{
public:
 template <typename T>
  class man
 {
 public:
  print(T a)
  {
   cout<<a;
    
  }

};
template <typename T2>
  void print(T2 a)
{
  cout<<a;
};
protected:
private:
};
                         1個好的例子
                           template <typename T>   class A
                                {      public:
                                                      template <typename T1>
                                                      A&    operator =(const A<T1> & );
                               }
                               如此則A 的對象可以用其他型的對象賦值了
     在使用時才實例化
                                        但是其定義比較駭人
                         template <typename T>
                                     template<typename T1>
                                     A<T>& A<T>::operator=(const A<T1>& a)
                                   { ...........................}

6.類模版的特化
      特化1個類模板（所有成員必須特化包括靜態(tài)類數(shù)據(jù)成員(vc),但友元模板（1：1）可以
不特化，當作一個顯示實參的函數(shù)模板處理即可）或特化1個模板成員函數(shù)

         模板成員函數(shù)特化是定義必須出現(xiàn)在實現(xiàn)文件（cpp)中
       語法為
    void man<int>::f(void)
{
............................
}

類特化
template <>
class man<int>
{
       ......//中所有類型參數(shù)以int 替代
};

  man<int>::man()
{
......
}

void man<int>::f(void)
{
}
注意類成員中
   static const 有序類型可以在體內(nèi)初始化static const int a=10;
                        僅僅static 必須在體外
                                                               static int a;
                                                              int woman::a=10;
   非特化
   template <typename T>
   int man<T>::size=10;
   特化
   int man<char>::size=10;
7偏特化
   類模板有1個以上模版參數(shù)（類型參數(shù)，非類型參數(shù)）
              某些模版參數(shù) 被實際的型和值取代（注意是取代，不是增加，減少）
      如：

//////////////////頭文件
       template <typename T1,typename T2,int size>
class wc
{
public:
wc()
{
  cout<<"\n int T1,T2, int";
}
protected:
private:
};
template <typename T,int size>
class wc<T* ,T,size>
{
public:
wc()
{
  cout<<"\n in T *, T ,size";
}
protected:
private:
};
template <typename T,int size>
class wc<T* ,float,size>
{
public:
wc()
{
  cout<<"\n in T* ,float,size";
}
protected:
private:
};
template <typename T>
class wc<T* ,float,80>
{
public:
wc()
{
  cout<<"\n in T* ,float,80";
}
protected:
private:
};
///////頭文件
//////main()
wc<int,float,10> wc1;
wc<int* ,int ,20> wc2;
wc<int*,float,39> wc3;
wc<int*,float,80>wc4;
///////main() ,在vc 7 上通過
//////main()

8.預設模板參數(shù)(只有在類模板中才指定，1 . 明確指定 a<int,int>   ,直接定義時 man<> kkk;2. a<T,T> )
template <typename T,typename T1=float>
class man
{
..........
}

寫到這里突然想到
                  class A {
                            virtual void   print();
                              };
                  class B:public A {
                                          virtual void print();
                                          };
B b;
                 A *a =&b;
                a->print();//調(diào)用 B的，此時 print()中的this 指針是 B * const,使用B 的接口 ;

9.雙重模板參數(shù)（很有用）
                template <typename T,typename G =man<T> >
class baby
{
public:
baby ()
{
   cout<<"\n in baby";
}
protected:
private:
};//類型參數(shù)可以是類類型

baby<int, man<float> > b; //ok
////////////////////////
template <typename T,template <typename G> class TT>//可以省略為 template <typename T ,template<typename>  class  TT>
class son
{
public:
   TT<T> * a;
     son()
  {
           a=0;
   cout<<"\n in son";
  }
protected:
private:
};
   son<int, man> b;//則就含有了 man<int > * a;
TT 是模板占位符號，是一個帶1個類型參數(shù)的類模板，如果其有默認模板參數(shù) 則忽略掉
所以 GG若帶默認的模板應該如下
            template <typename T, template <typename T2, typename= man<T2> > class GG>
class son
{
}

/////////   類模板類型參數(shù) 同時還可以是類模板

10. 字符串常量在模板中的注意事項

           char * a="hi ,friend ";///"hi, friend" 文字常量是 const char [10] 類型左值轉換到 const char *
限定轉換到 char *,
                template <typename T〉
      ostream& operator <<(ostream & os, const T & b)；//注意只有const 才能接受臨時變量

             cout<<"hi,friend";
              cout<<"bad";
/////2個不同的模板實例
   typeid(變量).name();///直接打印出變量類型
寫到這，閑扯下：
    棧區(qū)，堆區(qū)，全局（靜態(tài)）區(qū)，文字常量，代碼區(qū)，5個大區(qū)，這個是我聽說的
////////////////////////////////////////////////
11.模板的編譯模型
     在實例化點必須能找到定義//原則
                           只能使用包含模式了，
a..h. cpp 在 .h最后一行包含進 cpp
b. 全部在h 或 cpp

                     分離模式,目前支持的export 關鍵字i的編譯器很少（vc.net 不支持）

12.
函數(shù)指針類型也能做模板類型參數(shù)

bool minn( int a, int b)

{

return a < b;

}

template < typename T1,typename T2 >

const T1 & mymin( const T1 & t1, const T1 & t2, T2 t3 )

{

return t3(t1,t2) ? t1:t2;

}

void main()

{

cout << mymin( 2 , 3 ,minn);

}

13.
模板參數(shù)可以是個類模板
template <typename T>
class a
{
};
a< vector <int> >;

template <typename T, typename T2,template <typename T,typename T2> class con >
void add(con<T,T2>,con<T,T2>)
{
cout<<"ok";
}

add(a,b)//特殊在于需要推導,vc 7 可以從類模板中推導出參數(shù)類型

template <typename T,template <typename T2,typename T3> class con >
class ggoo
{
public:
con<T,T> a;
con<int,int> b;

protected:
private:
};

ggoo<int,double, b> kk;//b<int,double>, con 的模板參數(shù)可以任意