C++初学者进来看看吧！

//函数指针不能用标准转换成void*.  
  typedef   int   (*PFV)();  
  extern   PFV   testCases[10];//函数指针数组  
  extern   void   reset(void*);  
  int   main(){  
  //...  
  reset(testCases[0]);//错误，int(*)()  
  //之间不存在标准转换  
  return   0;  
  }  
   
   
  //函数重载解析细节  
  //候选函数：  
  void   f();  
  void   f(int   );  
  void   f(double   ,double   =   3.4);  
  void   f(double   char*,   char*);       //四个在调用点上可见。  
  int   main(){  
  f(5.6);//这个调用有四个候选函数  
  return   0;  
  }  
   
  namespace   NS{  
  class   c{/*...*/};  
  void   takec(c&);  
  }  
  //cobj的类型是在名字空间NS中被声明的类C  
  NS::c     cobj;  
  int   main(){       //在调用点没有tacec()可见  
  tacec(cobj);//ok:调用NS::takec(c&)  
                                          //因为实以类型是NS::c  
                                        //所以考虑在名字空间NS中声明的函数takec()  
  return   0;  
  }  
  //在实参类型所在的名字空间中声明的同名函数也是候选函数。  
   
  char   *format(int   );                           //全局域声明函数被隐藏，  
  void   g(){　　　　　　　//在调用点上不可见。　　　  
  char   *format(double   );  
  char   *format   (char   *);  
  format   (3);//调用format(double)  
  }  
                                           
  namespace   libs_R_us{  
  int   max   (int   ,int   );  
  double   max   (double   ,   double   );  
  }  
  char   max   (char   ,char);  
  void   func()  
  {  
      //名字空间的函数不可见  
  //调用全局函数三次  
  max(87,65);  
  max   (35.5,76.6);  
  max('j','l');  
  }  
  //用using声明使名字空间函数可见。  
   
  //若有char   max   (char,char);  
  using   libs_R_us::max;//using   声明，在调用点可见。  
  　　　　　　　　　　//分别调用三个max函数  
   
  void   func()  
  {  
      //using   声明,全局域中max(char,   char)被隐藏。  
  using   libs_R_us::max;  
  //函数调用如上  
  }  
   
  //在全局域中使用using   指示符  
  char   max   (char   ,char   );  
  using   namespace   libs_R_us;//using   指示符  
  //使三个max都可见  
  //若  
  void   func()  
  {  
    //using   指示符  
  using   namespace   libs_R_us;  
  //函数调用如上  
  }  
  //三个max   都可见  
  　//记住:using指示符使名字空间成员可见，就好像它们是  
  //在名字空间外，在定义名字空间的位置上被声明的一样  
   
  //缺省实参  
  extern   void   ff(int   );  
  extern   void   ff(long,   int   =0);  
  int   main(){  
  ff(2L);//匹配ff(ling,   0);  
  ff(0,0);//匹配ff(long,   int);  
  ff(0);//　　　ff(int);  
  ff(3.14);//错误，二义性。  
   
  //函数模板的定义  
  template<class   Type>  
  Type   min(Type   a,Type   b){  
  return   a<b?a:b;  
  }  
  int   main(){  
  //ok:int   min(int,int);  
  min(10,20);  
  //ok:double   min(souble,   double);  
  min(10.0,20.0);  
  return   0;  
  }  
   
   
  template<class   Type,int   size>  
  Type   min(const   Type(&r_array)[size])  
  {  
    /*找到数组中元素最小值的参数化函数*/  
    Type   min_val   =   r_array[0];  
    for(int   i   =   1;i<size;++i)  
        if(r_array[i]<min_val)  
            min_val   =   r_array[i];  
  return   min_val;  
  }  
   
   
  typedef   double   Type;  
  template<class   Type>  
      Type   min(Type   a,   Type   b)  
    {  
        //tmp类型为模板参数　type  
        //不是全局typedef  
  Type   tmp   =   a<b?a:b;  
    return   tmp;  
  }  
  //全局域中声明了与模板参数同名的对象，或类型，  
  //则该全局名将被隐藏。  
   
  template<class   Type>  
  Type   min(Type   a,   Type   b)  
  {  
      //错误：重新声明模板参数Type  
      typedef   double   Type;  
      Type   tmp   =   a<b?a:b;  
        return   tmp;  
  }  
  //函数模板定义中声明的对象或类型不能与模板参数同名。  
   
  //ok：T1表示min()的返回类型  
  //T2和T3表示参数类型  
  template<class   T1,class   T2,class   T3>  
      T1   min(T2,T3);  
  //模板类型参数名可以被用来指定函数模板的返回值。  
   
   
  //错误：模板参数名Type的非法重复使用。  
  template<class   Type,class   Type>  
  Type   min(Type,Type);  
  //参数表中，同一模板参数只能被使用一次！  
   
   
  //ok:关键字typename和class   可以混用  
  template<typename   T,class   U>  
  T   minus(T*,U);  
   
  //错误：必须是<typename   T,class   U>或  
  //<typename   T,typename   U>  
  template<typename   T,U>  
      T   sum(T*,U);  
   
   
  template<class   parm,   class   U>  
    parm   minus   (parm*   array,   U   value>  
  {  
      parm::name   *p;     //这是一个指针声明还是乘法？  
  　｝  
  //parm是一个类  
  //修改如下：  
  tempate<class   parm,class   U>  
    parm   minus   (parm*array,   U   value)  
    {  
        typename   parm::name   *p;//ok：指针声明  
  }  
  //typename告诉编译器是类型表达式  
   
   
  //ok:   关键字声明为inline，放在参数表后面  
  template<typename   Type>  
  inline                                                                   //inline或extern  
    Type   min(Type,Type);  
     
  //错误：inline指示符没有放在参数表后面  
  inline  
  template<typename   Type>  
  Type   min(Array<Type>,int);  
   
  template<typename   Type,int   size>  
  Type   min(Type<&r_array)[size])  
  {Type   min_val   =   r_array[0];  
    for(int   i   =   1;i<size;++i)  
      if(r_array[i]<min_val)  
          min_val   =   r_array[i];  
            return   min_val;  
  }  
  //size没有被指定——ok  
  //size   =   初始化表中的值的个数  
  int   ia[]   =   {10,7,14,3,25};  
  double   da[6]   =   {10.2,7.1,14.5,3.2,25.0,16.8};  
   
  #incluce<iostream>  
  int   main()  
  {  
      //为5个int   的数组实例化min()  
  int   i   =   min   (ia);  
  if(   i   !=   3   )  
        cout<<"??oops:integer   min()   failed\n";  
          else   cout<<"!!ok:integer   min()   worked\n";  
  //为6个double   的数组实例化min()  
  double   d   =   min   (   da   );  
  if   (   d   !=   3.2   )  
        cout   <<   "??oops:double   min()   failed\n";  
    else   cout<<   "   !!ok:double   min()   worked\n   ";  
    return   0;  
  }  
     
  template<typename   Type,int   size>  
    Type   min(Type(&p_array)[size]){/*...*/}  
  //pf指向int   min(int(&)[10])  
  int   (*pf)(int(&)[10])   =   &min;  
  //pf的类型是指向函数的指针  
  //函数模板在它被调用或取其地址时被实例化。  
   
  template<typename   Type,int   size>  
    Type   min(Type(&r_array)[size]){/*...*/}  
  typedef   int(&rai)[10];  
  typedef   double(&rad)[20];  
  void   func(int(*)(rai));  
  void   func(double   (*)(rad);  
  int   main(){  
  //错误：哪一个min()的实例？  
  func(&min);  
  }  
   
  //取函数模板实例的地址时，必须为模板实参决定一个唯一的类型或值。  
  //因为函数func()被重载了，不能为模板参数决定唯一的类型和值。  
  //调用func()无法实例化下面的任何一个函数。  
  min(int(*)(int(&)[10]))  
  min(double(*)(double(&)[20]))  
  int   main(){  
  //ok:强制转换指定实参类型  
  func(static_cast<double(*)(rad)>(&min));}  
   
   
  //模板实参推演  
  template<class   Type,int   size>  
  Type   min(Type(&r_array)[size]){/*...*/}  
  //min()函数是一个引用，它指向了一个Type类型的数组；  
  void   f(int   pval[q]){  
  //错误：Type(&)[]!=int*  
  int   ival   =   min(pval);  
  }  
  //为了匹配函数参数，函数实参必须也是一个表示数组类型的左值。  
   
  double   da[8]   =   {10.3,7.2;14.0,3.8,25.7,6.4,5.5,16.8};  
  //模板实参推演期间决定模板实参的类型时，编译器不考虑函数模板实例的返回类型。  
  int   il   =   min(   da   );  
   
  //当函数模板被调用时，对函数料参类型的检查决定了模板实参的类型和值，称为模板实参推演。 问题点数：100、回复次数：50Top

1 楼du51（郁郁思扬）回复于 2006-04-29 01:48:28 得分 1

学习了.谢谢.Top

2 楼anyue417（振浩）回复于 2006-04-29 03:22:46 得分 1

学习了too，谢谢too.Top

3 楼cunsh（村少）回复于 2006-04-29 06:44:40 得分 1

mark  
  xuexi;Top

4 楼yuanchuang（元创）回复于 2006-04-29 06:56:29 得分 1

留名学习，加入收藏夹，要是ＣＳＤＮ的收藏夹能有３００就好了Top

5 楼dch4890164（巴拉克）回复于 2006-04-29 08:09:25 得分 1

收藏  
  呵呵  
  Top

6 楼goodluckyxl（被人遗忘的狗）回复于 2006-04-29 08:36:18 得分 1

不错     可惜我不懂c++Top

7 楼barbara2008（亦农）回复于 2006-04-29 08:37:16 得分 1

学习了,收藏Top

8 楼xpdavis（咕嘟-不想孤独）回复于 2006-04-29 08:38:24 得分 1

学习Top

9 楼gold123d（Love linux Love shell）回复于 2006-04-29 11:26:28 得分 1

好东西,学习一下..Top

10 楼jxab269962465（）回复于 2006-04-29 23:34:14 得分 1

刚学没看懂顶了Top

11 楼luocolor1（）回复于 2006-04-29 23:40:59 得分 1

markTop

12 楼cattlenzq（吃狼的豆腐（不要给分了，散起来真麻烦！））回复于 2006-04-30 00:12:26 得分 1

学习了tootootootootootootootootootootootoo，谢谢tootootootootootootootootootootootootootootoo.Top

13 楼ruyitao（记忆不陌生）回复于 2006-04-30 00:43:44 得分 1

LZ，希望你在C++方面会有所建树！Top

14 楼legend808（冬雪）回复于 2006-04-30 10:50:00 得分 1

恩  
  值的收藏Top

15 楼zlcolin（疯狂土豆）回复于 2006-04-30 11:21:55 得分 1

谢谢楼主了，哈哈，我正想整理这些呢。。。  
  呵呵呵。。。Top

16 楼MagicCarmack（MagiC++）回复于 2006-05-01 02:45:54 得分 1

收藏起Top

17 楼gold123d（Love linux Love shell）回复于 2006-05-01 22:08:44 得分 1

以后再看Top

18 楼fiftymetre（50米深蓝）回复于 2006-05-02 16:44:23 得分 10

//当函数模板被调用时，对函数料参类型的检查决定了模板实参的类型和值，称为模板实参推演。  
   
   
  是因为类模板板必须得显式的特化的，但函数模板实参推导机制可用于间接地特化类模板。  
   
  template<typename   A1,   typename   A2,   tymename   R>  
   
  class   PFun2   :   public   std::binary_function<A1,A2,R>   {  
   
    public:  
       
    explicit   PFun2   (R   (*fp)(A1,A2)   ):fp_(fp){}  
   
    R   operator   ()   (A1   a1,   A2   a2)   const  
   
    {   return   fp_   (   a1,a2);}  
   
  private:  
   
    R   (*fp_)(A1,A2);  
   
  };     //这段代码是我在“C＋＋必＊＊＊”上看到的，当时真的要把偶看疯了，太难了感觉。  
   
   
  其实这是标准库中pointer_to_binary_function   模板和简化版。而你来直接实例化这个模板有点麻烦的。  
   
  bool   inGreater(int,int);  
   
  std::sort(b,e,PFun2<int,int,bool>(inGreater));     ：（  
   
  对于这种情况，一般可以提供一个“辅助函数”，只途就是在于推导模板实参，为的就是可以去特化一个类模板。  
   
  template   <typename   R,   typename   A1,typename   A2>  
   
  inline   PFun2<A1,A2,R>   makePFun(   R(*pf)(A1,A2)   )  
  {   return   PFun2<A1,A2,R>(pf);}  
  //....  
  std::sort(b,e,makePFun(isGreater));   ^_^  
   
  大意便是编译器能从单个函数实参的类型推导出实参类型和返回值类型。  
   
   
   
  PS:说的我都晕了。。。。。。  
   
   
   
   
  Top

19 楼Mypiger（深圳 step by step）回复于 2006-05-02 16:49:06 得分 1

THXTop

20 楼Azure_ceil（天蓝）回复于 2006-05-02 19:47:28 得分 1

接分~谢谢~Top

21 楼hbyufan（）回复于 2006-05-02 23:31:52 得分 1

hehe，我都看晕了Top

22 楼MarionTY（童童）回复于 2006-05-03 18:27:15 得分 1

学习Top

23 楼cc11405（）回复于 2006-05-03 18:31:21 得分 1

反正觉得C++比C要难的多了！还好！有这么多高手在！不用怕！Top

24 楼Error_Code（void）回复于 2006-05-03 20:13:29 得分 1

MARK...Top

25 楼ruyitao（记忆不陌生）回复于 2006-05-04 01:11:35 得分 17

template<class   Type>    
  //第一个参数是Type   *  
  Type   min2(Type*   array,   int   size)  
  {  
    Type   min_val   =   array[0];  
  for(int   i   =   1;i<size;++i)  
  if(array[i]<min_val)  
  min_val   =   array[i];  
  return   min_val;  
  }  
  int   ai[4]   =   {12,8,73,43};  
  int   main(){  
  int   size   =   sizeof(ai)/sizeof(ai[0]);  
  //ok:   从数组到指针的转换。  
  min2(ai,size);  
  }  
   
   
  template<class   Type>  
  //第一个参数是const   Type*  
  Type   min3(const   Type*   array,   int   size)){  
  //...  
  }  
  //调用如下：  
  int   *pi   =   &ai;  
  //ok：到const   int*的限定修饰转换  
  int   i   =   min3(pi,4);  
   
   
  template<class   Type>  
  class   Array{/*..*/};  
  template<class   Type>  
  Type   min4(Array<Type>&   array)  
  {  
      Type   min_val=   array[0];  
    for(int   i   =   1;i<array,size();++i)  
  if(array[i]<min_val)  
  min_val   =   array[i];  
  return   min_val;  
  }  
  //调用如下  
  template<class   Type>  
  class   ArrayRC:publec   Array<Type>{/*..*/};  
  int   main(){  
  ArrayRC<int>   ia_rc(ia,sizeof(ia>/sizeof(int));  
  min4(ia_rc);  
  }  
  //函数实参ia_rc类型为ArrayRC<int>，与Array<Type>&不完全匹配。  
  //函数实参ArrayRC<int>在模板实参被推演之前首先被转换成Array<int>型，  
  //然后Type的模板实参再被推演为int   ，被实例化的函数模板是min4(Array<int>&)  
   
   
  //显式模板实参  
  template<class   T>   T   min5(T,T){/*...*/};  
  unsigned   int   ui;  
  int   main(){  
  //错误：不能实例化min5(unsigned   int   ,int)  
  //必须是min5(unsigned   int,   unsigned   int)或min5(int,int)  
  min5(ui,1024);  
  }  
  //若有显式模板指定：  
  min5<unsigned   int>(ui,1024);  
  //实例化为min5(unsigned   int   ,usigned   int)  
   
   
  //以T或U作为返回类型？  
  template<class   T,class   U>  
  ???   sum(T,U);  
  //都不可以，都会在任何某点上失败  
  char   ch;  
  unsigned   int   ui;  
  //T和U都不用作返回类型  
  sum(   ch   ,   ui   );   //ok:U   sum(   T   ,   U   );  
  sum(     ui   ,   ch   );   //ok:T   sum(   T   ,   U   );  
  //引入第三方模板参数来指明函数模板返回类型。  
  template<class   T1,class   T2,class   T3>  
  T1   sum(T2,T3);  
  typedef   unsigned   int   ui_type;  
  ui_type   calc<char   ch,ui_type   ui){  
  ui_type   locl   =   sum(ch,   ui);  
  //ok:模板实参被显式指定  
  //T1和T3是unsigned   int   ,T2是char  
  ui_type   loc2   =   sum<ui_type,char,ui_type>(ch,ui);  
  }  
  //ok:T3是unsigned   int   ,从ui的类型中推演出来  
  ui_type　loc#   =   sum<ui_type,char>(ch,ui);  
  //T2,T3从pf的类型中推演出来  
  ui_type(*pf)(char,   ui_type)   =   &sum<ui_type>;  
  //错误:只能省略尾部的实参  
  ui_type   loc4   =   sum<ui_type,             ,ui_type>(ch,ui);  
   
  template<class   T1,class   T2,class   T3>  
  T1   sum(T2   op1,T3   op2){/*...*/}  
  void   manipulate   (int(*pf)(int,char));  
  void   manipulate(double   (*pf)(float,float));  
  int   main()  
  {  
      //错误：哪一个sum的实例？  
  　//int   sum(int,char   还是double   sum(float,float)?  
    manipulate(&sum);  
    //取实例：double   sum(float,float)的地址  
  //调用：void   mainpulate(double(*pf)(float,float));  
  manipulate(&sum<double,   float,float>);  
  }  
  //显示模板参数应该只用在完全需要它们来解决二义性，  
  //或不能被推演出来的上下文中使用模板实例时。  
  Top

26 楼ruyitao（记忆不陌生）回复于 2006-05-04 01:12:02 得分 17

//模板编译模式  
  //model1.h:  
  //包含模式：模板定义放在头文件中  
  template<typename   Type>  
  Type   min(Type   t1,Type   t2){  
  return   t1<t2?t1:t2;  
  }  
  //在使用模板实例之前包含模板定义  
  #include   "model1.h"  
  int   i,j;  
  double   dobj   =   min(i,i);  
   
   
  //分离编译模式  
  //model2.h  
  //分离模式：提供模板声明  
  template<typename   Type>   Type   min(Type   t1,Type   t2);  
  //model2.c  
  //模板定义  
  export   template   <typename   Type>  
  //模板min()被定义成可导出的模板。  
  //一个函数模板只能被定义为export一次。  
  Type   ;min(Type   t1,Type   t2){/*...*/}  
  //要使用模板min()只需在使用该实例之前包含这个头文件：user.c  
  #include   "modl2.h"  
  int   i,j;  
  double   d   =   min(i,j);//ok！  
   
  //显式实例化声明  
  template<typename   Type>  
  Type   sum(Type   op1,int   op2){/*...*/}  
  //显式实例化声明  
  template   int   *sum<int   *>(int   *,int   );  
  //该显式实例化声明要求用模板实参int   *实例化模板sum().  
  //在一个程序中只能出现一次。  
  //用来帮助程序员控制模板实例化发生的时间。  
   
   
   
  //显式实例化要与其它选择联合使用。  
  //在IBM编译器Visual   Age   for   C++   for   windows   版本3.5，  
  //压制模板隐式实例化的选项为　/ft-　。  
   
  //模板显式特化  
  //通用的模板定义  
  template<class   T>  
    T   max(T   t1,T   t2){  
  return   (t1>t2?t1:t2);  
  }  
  //想让每个实参都被解释成C风格的字符串。  
  //const   char*   显式特化：覆盖了来自通用模板定义的实例  
  typedef   const   char   *pcc;  
  template<>   pcc   max<pcc><pcc   s1,   pcc   s2){  
  return   (strcmp(s1,s2)>0?   s2:s1);  
  }  
   
  //可能的调用  
  #include<iostream>  
  //函数模板max()的定义必须对const   char   *特化  
  int   main(){  
  //调用实例：int   max<int>(int,int);  
  int   i   =   max(10,5);  
  //调用显式特化：const   char*max<const   char   *>(const   char*,const   char*);  
  const   char   *p   =   max(   "hello","world");  
  cout<<"i:"<<i<<"p:"<<p<<endl;  
  return   0;  
  }  
  //函数模板特化的声明  
  template<>   pcc   max<pcc>(pcc,pcc);  
  //template<>   显式特化  
   
  template<class   T1,class   T2,class   T3>  
  T1   sum(T2   op1,T3   op2);  
  //显式特化声明  
  //错误：T1必须显式指定，因它推演不出来  
  template<>   double   sum(float,   float);  
  //ok:T1的实参被显式指定  
  template<>   double   sum<double>(float,float);  
  //ok:T1,T2,T3的实参都被显式指定  
  template<>   int     sum<int,char,char>(char,char);  
  //省略template<>并不总是错的  
  //通用模板：  
  template<class   T>  
  T   max(T   t1,T   t2){/*...*/   }  
  //ok,普通函数定义  
  const   char*   max(const   char*,const   char*);  
   
  //------------------max.h------------------  
  template<class   Type>  
  Type   max(Type   t1,Type   t2){/*...*/}  
  //const   char*模板显式特化的声明  
  typedef   const   char*   pcc;  
  template<>   pcc   max<pcc>(pcc   s1,pcc   s2);  
  //----File1.c---  
  #include<iostream>  
  #include   "max.h"  
  void   another();  
  int   main(){  
  //const   char*   max<const   char*>(const   char*,const   char*)的特化；  
  const   char   *p   =   max   ("Hello","world");  
  //...  
  }  
  //一个程序中只使用一次显式特化，显式特化的模板函数必须要在使用前先声明。  
  //没有显式特化的和显式特化过的模板函数不可以放在同一个程序中使用。  
   
  //重载函数模板  
  template<typename   Type>  
  Type   sum(Type   *,int);  
  template<typename   Type>  
  Type   sum(Type,int   );  
  int   ia[1024];  
  //用sum<int*>(int*,int);实例化  
  int   ival1   =   sum<int>(ia,1024);  
  //最特化的模板函数一个模板要比另一个更特化，  
  //同名、同参个数，一个必能接受另一个能接受的实参的超集。  
  //比第二个接受更有限的实参集合的模板被称为是更特化的。  
   
  //模板定义中的名字解析  
  //－－－－primer.h－－－－  
  //这个声明是必需的，print(const   char*)在min()中被调用  
  void   print   (const   char   *);  
  //不依赖于模板参数的名字在模板定义中时被解析，  
  template   <typename   Type>  
      Type   min(Type*   array,   int   size){  
  //.....  
  print   ("Minimum   value   found:");  
  print   (min_val);  
  return   min_val;  
  }  
  #include<primer.h>  
  void   print   (int   );  
  //依赖于模板参数的名字在模板被实例化是被解析。  
  int   ai[4]   =   {12,8,73,45};  
  int   main   (){  
  int   size   =   sizeof(ai)/sizeof   (int);  
  //min(int   *,int   )的实例  
  min(&ai[0],size);  
  }  
  Top

27 楼ruyitao（记忆不陌生）回复于 2006-05-04 01:12:29 得分 17

//名字空间和函数模板  
  //----------primer.h----------  
  namespace   cplusplus_primer{  
  //模板定义被隐藏在名字空间中。  
  //在名字空间之外使用时，必须被限定或提供using   声明  
  template<class   Type>  
      Type   min(Type*   array,int   size){/*...*/}  
  }  
  //----------user.c----------  
  #include<primer.h>  
  int   ai[4]   =   {12,8,73,45};  
  int   main(){  
  int   size   =   sizeof(ai)/sizeof(ai[10]);  
  //错误：没有找到函数min()  
  min(&ai[0],size);  
  using   cplusplus_primer::min;//using   声明  
  //ok:指向名字空间cplusplus_primer   中的min()  
  min(&ai[0],size);  
  }  
   
  //SmallInt的定义，将会看到特化的使用方法。  
  class   SmallInt{  
  public:  
  SmallInt(int   ival):value(ival){};  
  friend   bool   compare   less   (const   SmallInt   &,const   SmallInt   &);  
  private:int   value;  
  };  
  bool   compareLess(const   SmallInt   &parml,const   SmallInt   &parm2){  
  return   parm1.value<parm2.value;  
  }  
  //指针对SmallInt   数组的min()特化  
  template<>   SmallInt   min<SmallInt>(SmallInt   *   array,int   size)  
  {  
        SmallInt   min_val   =   array[0];  
      for   (   int   i   =   1;i<size;++i)  
  //使用函数compareLess()比较  
  if(compareLess(array[i],min_val))  
  min_val   =   array[i];  
  print   ("Minimum   value   found:");  
  print(min_val);  
  return   min_val;  
  }  
  //在哪里特化呢？  
  //----------primer.h----------  
  namespace   cplusplus_primer{  
    //模板定义被隐藏在名字空间中  
  template<class   Type>  
      Type   min(Type*   array,int   size){/*...*/}  
  }  
  //----------user.c----------  
  #include<primer.h>  
  #include   "user.h"  
  namespace   cplusplus_primer{  
    //cplusplus_primer::min()的特化  
  template<>SmallInt   min<SmallInt>(SmallInt*   array,int   size)  
  {/*...*/}  
  }  
  SmallInt   asi[4];  
  int   main(){  
  using   cplusplus_primer::min;//using   声明  
  int   size   =   sizeof(asi)/sizeof(SmallInt);  
  //min(SmallInt   *,int)的实例化  
  min(&asi[0],size);  
  }  
  //或者  
  //----------user.c----------  
  #include<primer.h>  
  #include   "user.h"  
  //cplusplus_primer::min()的特化  
  //此特化的名字被限定修饰  
  template<>SmallInt   cplusplus_primer::  
            min<SmallInt>(SmallInt   *array,int   size)  
  {/*...*/}  
  //...Top

28 楼cunsh（村少）回复于 2006-05-04 01:38:20 得分 1

mark  
  xuexi;Top

29 楼bila（小毛）回复于 2006-05-04 11:56:22 得分 1

学习!Top

30 楼BaiYangSpirit（空）回复于 2006-05-04 12:16:12 得分 1

markTop

31 楼lijunxd（）回复于 2006-05-07 22:41:33 得分 1

先copy下来Top

32 楼guandao（管道）回复于 2006-05-07 23:40:32 得分 1

学习Top

33 楼TERRYYRRET（命运）回复于 2006-05-08 07:04:01 得分 1

学习Top

34 楼chentaolimei（随心所欲而不逾矩）回复于 2006-05-09 04:09:13 得分 0

操作符优先级    
     
  操作符                                                                   功能                                                               用法    
  ::                                                                                 全局域                                                       ::name    
  ::                                                                                 类域                                                           ::name    
  ::                                                                                 名字空间域                                               namespace::name    
  .                                                                                 成员选择                                                   object.member    
  ->                                                                             成员选择                                                             pointer->member    
  []                                                                               下标                                                                     variable[   expr   ]    
  ()                                                                               函数调用                                                         name(expr_list)    
  ()                                                                               类型构造                                                         type(expr_list)    
  ++                                                                             后置递增                                                     lvalue++    
  --                                                                                     后置递减                                                       lvalue--    
  typeid                                                               类型ID                                                                         typeid(type)    
  typeid                                                               运行时刻类型   ID                                                             typeid(expr)    
  const_cast                                             类型转换                                                   const_cast<type>(expr)    
  dynamic_cast                                   类型转换                                                               dynamic_cast<type>(expr)    
  reinterpret_cast                               类型转换                                                         reinterpret_cast<type>(expr)    
  static_cast                                                   类型转换   s                                             tatic_cast<type>(expr)    
  sizeof                                                                   对象的大小                                                       sizeof   object    
  sizeof                                                               类型的大小                                                           sizeof(   type   )    
  ++                                                                         前置递增                                                                           ++lvalue    
  --                                                                           前置递减                                                                             --lvalue    
  ~                                                                                 按位非                                                                           ~expr    
  !                                                                                 逻辑非                                                                                     !expr    
  -                                                                                 一元减                                                                                   -expr    
  +                                                                               一元加                                                                                 +expr    
  *                                                                                         解引用                                                                     *expr    
  &                                                                                       取地址                                                                         &expr    
  ()                                                                                       类型转换                                                                       (type)expr    
  new                                                                                   分配对象                                                                   new   type    
  new                                                                   分配/初始化对象                                                   new   type(expr_list)    
  new                                                                       分配/替换对象                                                                       new(expr_list)type(expr_list)    
  new                                                                                     分配数组                                                             所有的形式    
  delete                                                               释放对象                                                                             所有的形式    
  delete                                                                 释放数组           所有的形式    
  ->*     指向成员选择   pointer->*pointer_to_member    
  .*     指向成员选择   object.*pointer_to_member    
  *     乘     expr   *   expr    
  /     除     expr   /   expr    
  %     取模   求余       expr   %   expr    
  +     加     expr   +   expr    
  -     减     expr   -   expr    
  <<     按位左移     expr   <<   expr    
  >>     按位右移     expr   >>   expr    
  <     小于     expr   <   expr    
  <=     小于等于     expr   <=   expr    
  >     大于     expr   >   expr    
  >=     大于等于     expr   >=   expr    
  =     等于     expr   ==   expr    
  !=     不等于     expr   !=   expr    
  &     按位与     expr   &   expr    
  ^     按位异或     expr   ^   expr    
  |     按位或     expr   |   expr    
  &&     逻辑与     expr   &&   expr    
  ||     逻辑或     expr   ||   expr    
  ?:     条件表达式     expr   ?   expr   :   expr    
  =     赋值     lvalue   =   expr    
  =,*=,/=,%=,+=,-=,<<=,>>=,&=,|=,^   复合赋值     lvalue   +=   expr   等    
   
  throw     抛出异常   throw   expr    
  ,     逗号   expr,   exprTop

35 楼romanticlife（充满生活的味道）回复于 2006-05-09 08:50:01 得分 1

费心了，谢谢你！  
                                  ^-^Top

36 楼ugg（逸学堂(exuetang.net)）回复于 2006-05-09 09:10:06 得分 1

不错，学习了Top

37 楼wantdrink（咿咿哟哟）回复于 2006-05-09 16:52:44 得分 1

收藏，谢谢Top

38 楼ycy1412（笑我飘零）回复于 2006-05-09 17:22:59 得分 1

收藏！！！！！！！！！！！Top

39 楼zhangwenyi83（文逸）回复于 2006-05-09 19:37:24 得分 1

看完这些东西,感觉太多了,多的害怕!先收藏了，慢慢看了。Top

40 楼archerchun（云步风行）回复于 2006-05-09 19:59:12 得分 1

看看Top

41 楼geniuscaobo（也许会有一天）回复于 2006-05-10 10:10:15 得分 1

markTop

42 楼sun132008（努力努力再努力）回复于 2006-05-10 18:36:47 得分 1

markTop

43 楼liwuwu0308（星火）回复于 2006-05-11 00:01:24 得分 1

很有用，先mark低，谢谢~~~~~~~Top

44 楼Edge_23（）回复于 2006-05-11 14:14:53 得分 1

很基础,很简单,但是很使用,顶!!!好东西!!!  
  Thanks!!Top

45 楼kingbo2006（韫知）回复于 2006-05-22 13:40:49 得分 0

很基础Top

46 楼greymist（井底之蛙）回复于 2006-05-22 23:42:24 得分 0

markTop

47 楼zhaomu（）回复于 2006-05-24 02:55:02 得分 0

十分感谢Top

48 楼gotoliuchao（猪顿）回复于 2006-05-29 15:42:38 得分 0

xiexie   ni   oTop

49 楼flypanda（SEED 积攒力量）回复于 2006-05-31 20:45:29 得分 0

学习  
  Top

50 楼qsg1982（）回复于 2006-06-04 03:16:33 得分 0

好贴   谢楼主了`~Top

相关问题

• 帖主：chentaolimei
• du51
• anyue417
• cunsh
• yuanchuang
• dch4890164
• goodluckyxl
• barbara2008
• xpdavis
• gold123d
• jxab269962465
• luocolor1
• cattlenzq
• ruyitao
• legend808
• zlcolin
• MagicCarmack
• gold123d
• fiftymetre
• Mypiger
• Azure_ceil
• hbyufan
• MarionTY
• cc11405
• Error_Code
• ruyitao
• ruyitao
• ruyitao
• cunsh
• bila
• BaiYangSpirit
• lijunxd
• guandao
• TERRYYRRET
• romanticlife
• ugg
• wantdrink
• ycy1412
• zhangwenyi83
• archerchun
• geniuscaobo
• sun132008
• liwuwu0308
• Edge_23

• C/C++ Blog
• C/C++类图书
• C/C++类源码下载