C#2.0泛型学习

快来打我* 2021-12-09 00:33 228阅读 0赞

C\#的泛型能力有CLR在运行时支持，它既不同于C++在编译时所支持的静态模板，也不同于Java在编译器层面使用“搽拭法”支持的简单的泛型。  
       C\#的泛型支持包括类、结构、接口、委托共四种泛型类型，以及方法成员。  
       C\#的泛型采用“基类，接口，构造器，值类型/引用类型”的结束方式来实现对类型参数的“显示约束”，它不支持C++模板那样的基于签名的隐式约束。

// C\#泛型演示 
      class  Stack < T > 
    \{ 
         private  T\[\] store; 
         private   int  size; 
         public  Stack() 
        \{ 
            store  =   new  T\[ 10 \]; 
            size  =   0 ; 
        \} 
 
         public   void  Push(T x) 
        \{ 
            store\[size \++ \]  =  x; 
        \} 
 
         public  T Pop() 
        \{ 
             return  store\[ \-- size\]; 
        \} 
    \} 
    所谓泛型，即通过参数化类型来实现在同一份代码上操作多种数据类型。泛型编程是一种编程范式，它利用“参数化类型”将类型抽象化，从而实现更为灵活的运用。

// 泛型类与结构 
      class  C < U, V >  \{ \}   // 合法 
 
     class  D : C < string ,  int >  \{ \}   // 合法 
 
     class  E < U, V >  : C < U, V >  \{ \}   // 合法 
 
     class  F < U, V >  : C < string ,  int >  \{ \}   // 合法 
 
     class  G : C < U, V >  \{ \}   // 非法 
      C\#除可单独声明泛型类型（包括类与结构）外，也可在基类中包含泛型类型的声明。但基类如果是泛型类，它的类型参数要么实例化，要么来自于子类（同样是泛型类型）声明的类型参数。

// 泛型类型的成员 
      class  C < V > 
    \{ 
         public  V f1;   // 声明字段 
          public  D < V >  f2;   // 作为其他泛型类型的参数 
          public  C(V x) 
        \{ 
             this .f1  =  x; 
        \} 
    \} 
     泛型类型的成员可以使用泛型类型声明中的类型参数。但类型参数如果没有任何约束，则只能在该类型上使用System.Object集成的公有成员。

// 泛型接口 
      interface  IList < T > 
    \{ 
        T\[\] GetElements(); 
    \} 
 
     interface  IDictionary < K, V > 
    \{ 
         void  Add(K key, V value); 
    \} 
     // 泛型接口的类型参数要么已经实例化， 
     // 要么来源于实现类声明的类型参数 
      class  List < T >  : IList < T > , IDictionary < int , T > 
    \{ 
         public  T\[\] GetElements() \{  return   null ; \} 
         public   void  Add( int  index, T value) \{ \} 
    \}

// 泛型委托 
      delegate   bool  Predicate < T > (T value); 
     class  X 
    \{ 
         static   bool  F( int  i) \{ ![dot.gif][] \} 
         static   bool  G( string  s) \{ ![dot.gif][] \} 
 
         static   void  Main( string \[\] args) 
        \{ 
            Predicate < string >  p2  =  G; 
            Predicate < int >  p1  =   new  Predicate < int > (F); 
        \} 
    \} 
泛型委托支持在委托返回值和参数上应用参数类型，这些参数类型同样支持可以附带合法的约束。

// 泛型方法的声明和调用 
      public   class  Finder 
    \{ 
         // 泛型方法声明 
          public   static   int  Find < T > (T\[\] items, T item) 
        \{ 
             for  ( int  i  =   0 ; i  <  items.Length; i \++ ) 
            \{ 
                 if  (items\[i\].Equals(item)) 
                \{ 
                     return  i; 
                \} 
            \} 
             return   \- 1 ; 
        \} 
    \} 
 
     // 泛型方法调用 
       int  i  =  Finder.Find < int > ( new   int \[\] \{  1 ,  3 ,  4 ,  5 ,  6 ,  8 ,  9 , \},  6 );

// 泛型方法的重载 
      class  MyClass 
    \{ 
         void  F1 < T > (T\[\] a,  int  i);  
         void  F1 (U\[\] a,  int  i);      // 不可以构成重载方法 
 
         void  F2 < T > ( int  x); 
         void  F2( int  x);                 // 可以构成重载 
 
         void  F3 < T > (T t)  where  T : A; 
         void  F3 < T > (T t)  where  T : B;    // 不可以构成重载方法 
 
    \}

// 泛型方法的重写,泛型方法被覆盖时，约束被默认继承 
      abstract   class  Base 
    \{ 
         public   abstract  T F < T,U > (T t,U u)  where  U:T; 
    \} 
 
     class  Derived : Base 
    \{ 
         public   override  X F < X, Y > (X x, Y y) 
        \{ 
  
        \} 
    \}

泛型中的约束:基类约束

class  A \{  public   void  F1() \{ \} \} 
     class  B \{  public   void  F2() \{ \} \} 
     class  C < S, T > 
         where  S : A  //  S继承自A 
          where  T : B  //  T继承自B 
     \{ 
         //  可以在类型为S的变量上调用F1， 
         //  可以在类型为T的变量上调用F2 
     \}

泛型中的约束:接口约束

interface  IPrintable \{  void  Print();  
    \} 
     interface  IComparable < T >  \{  int  CompareTo(T v);\} 
     interface  IKeyProvider < T >  \{ T GetKey(); \} 
     class  Dictionary < K,V >   
     where  K: IComparable < K >   
     where  V: IPrintable, IKeyProvider < K >   
    \{  
     //  可以在类型为K的变量上调用CompareTo，  
     //  可以在类型为V的变量上调用Print和GetKey  
     \}

泛型中的约束:构造器约束

class  A \{  public  A() \{ \} \}  
 class  B \{  public  B( int  i) \{ \} \}  
 class  C < T >   
 where  T :  new ()  
\{  
 // 可以在其中使用T t=new T();   
 \}  
C < A >  c = new  C < A > ();  // 可以，A有无参构造器 
 C  c = new  C ();  // 错误，B没有无参构造器

泛型中的约束:值/引用类型约束

public   struct  A \{  \}  
 public   class  B \{  \}  
 class  C < T >   
 where  T :  struct   
\{  
 //  T在这里面是一个值类型  
 \}  
C < A >  c = new  C < A > ();  // 可以，A是一个值类型 
 C  c = new  C ();  // 错误，B是一个引用类型

学习中，来源李建忠老师PPT

转载于:https://www.cnblogs.com/lc329857895/archive/2008/01/17/1043141.html

[dot.gif]: /images/20211209/8e5ba2de7180407582b12cdab6002c59.png