随笔 - 25  文章 - 29  trackbacks - 0
<2006年5月>
30123456
78910111213
14151617181920
21222324252627
28293031123
45678910

常用链接

留言簿(4)

随笔分类(22)

随笔档案(25)

文章分类(2)

文章档案(2)

相册

最新随笔

搜索

  •  

积分与排名

  • 积分 - 54416
  • 排名 - 407

最新评论

阅读排行榜

评论排行榜

                              这几天看了下模板 ,以下是个人的些心得,高手见笑了
1.类模版 实例 对象定义 引起 实例化
                            指针,引用 不会引起实例化
类非型参数  只能是 整形,枚举,外联结,且应为一个常量编译时就应确定
                    浮点型,类类型,。。。都不可以
2.class templates 的成员函数 在调用和取地址时实例化,在类实例化时不会自动实例化
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.类模版的静态成员
      并不在模版定义时实例化,在类模版实例化时实例化,对应1个类型
template <typename T>
int man<T>::size=10;
而成员函数应为
  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个类模板(所有成员必须特化包括静态类数据成员(vc),但友元模板(1:1)可以
不特化,当作一个显示实参的函数模板处理即可) 或 特化1个模板 成员函数

         模板成员函数特化是定义必须出现在实现文件(cpp)中
       语法为
    void man<int>::f(void)
{
............................
}
      
类特化
 template <>
class man<int>
{
       ......//中所有类型参数以int 替代
};
      
  man<int>::man()
{
......
}

void man<int>::f(void)
{
}
注意  类成员中
   static const 有序类型可以在体内初始化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个以上模版参数(类型参数,非类型参数)
              某些模版参数 被实际的型和值取代(注意是 取代 ,不是增加,减少)
      如:

//////////////////头文件
       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.预设模板参数(只有在类模板中才指定 ,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();//调用 B的,此时 print()中的this 指针是 B * const,使用B 的接口 ;

9.双重模板参数(很有用)
                template <typename T,typename G =man<T> >
 class baby
 {
 public:
  baby ()
  {
   cout<<"\n in baby";
  }
 protected:
 private:
 };//类型参数可以是 类类型
        
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个类型参数的类模板,如果其有默认模板参数 则忽略掉  
所以 GG若带默认 的模板 应该如下
            template <typename T, template <typename T2, typename= man<T2>  > class GG>
class son
{
}

/////////   类模板类型参数 同时还可以是 类模板

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();///直接打印出变量类型
写到这,闲扯下:
    栈区,堆区,全局(静态)区,文字常量,代码区,5个大区,这个是我听说的
////////////////////////////////////////////////
11.模板的编译模型
     在实例化点必须能找到定义//原则
                           只能使用包含模式了,
a..h. cpp 在 .h最后一行包含进 cpp
b. 全部在h 或 cpp

                     分离模式,目前支持的export 关键字i的编译器很少(vc.net 不支持)


12.
函数指针类型也能做模板类型参数

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.
模板参数可以是个类模板  
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 可以从  类模板中推导出参数类型

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 的模板参数可以任意
 

posted on 2006-05-27 17:55 黄大仙 阅读(6066) 评论(3)  编辑 收藏 引用 所属分类: c++

FeedBack:
# re: 类模板(原创) 2007-04-11 10:50 @王一伟
好文,哈哈,下班了慢慢看看你写的  回复  更多评论
  
# re: 类模板(原创) 2009-06-06 17:33 鸣人
可以。  回复  更多评论
  
# re: 类模板(原创) 2010-03-26 22:52 nomatter9
谢谢了  回复  更多评论
  

只有注册用户登录后才能发表评论。
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理