在由4個不同類別

Question

此問題的陣列找出一個值由4層不同的類。問題是：

1. 運算符'<'不能應用於'T'和'int'類型的操作數。
2. 不能將類型'T'隱式轉換爲'int'。這是最小的方法。

在我看來，列表[i]就是我特別需要比較的東西。如果我刪除列表[i]並將其替換爲i它只是給我1000.如果我刪除if (item.Equals(list[i]))它給我0.

但我可以將數字添加到該整數，如果數字大於最小2）它承認或看到數字2.最後一部分可能沒有多大意義，很難解釋。

什麼或如何我可以比較給我的最小整數？我錯過了一些小事還是非常大的事？列表[我]什麼我需要甚至比較？

我仍然存在的問題是，當我嘗試進行比較時，它不能識別比較中的T，並且如果我在類參數中聲明它會導致其他類很多頭痛（也不會我平時看到IComparable接口在類參數）

我想，也許

public int min(ref T item) 
    { 
     int min = 1000; 
     T tempItem = list[0]; 

     for (int i = 0; i < next; i++) 
     { 
      if (list[i].CompareTo(tempItem) < 0) 
      { 
       tempItem = list[i]; 
       min = i; 
      } 
     } 
     item = tempItem; 
     return min; 

    } 

會的工作，但它仍然沒有。這個問題也被更新爲更多的問題與的CompareTo

using System; 

    namespace ArrayListNamespace 
    { 
     public abstract class ArrayList<T> 
     { 
     protected T[] list; 
     protected int length; 



     public ArrayList() 
     { 
      list = new T[100]; 
      length = 0; 
     } 

     public abstract void insert(ref T item); 


     public int remove(ref T item) 
     { 
      if (length == 0) return 0; 
      else 
      { 
       //find value, if it exists 
       for (int i = 0; i < length; i++) 
       { 
        if (item.Equals(list[i])) 
        { 
         list[i] = list[length - 1]; 
         length--; 
         return 1; 
        } 
       } 
       return -1; 
      } 
     } 
     public void print() 
     { 
      for (int i = 0; i < length; i++) 
      { 
       Console.WriteLine(list[i]); 
      } 
     } 
     public void removeAll(ref T item) 
     { 
      for (; ;) 
      { 
       int r = remove(ref item); 
       if (r == -1) break; 
      } 
     } 
     public void removeAt(int location) // probably can delete this 
     { 
      list[location] = list[length - 1]; 
      length--; 
     } 

     public int min(ref T item) 
     { 
      int min = 1000; 

      for (int i = 0; i < length; i++) 
      { 

        if (list[i] < min) 
        { 
         min = list[i]; 
        } 
      } 
      return min; 

     } 
    } 
} 

    using System; 
    using System.Collections.Generic; 
    using System.Linq; 
    using System.Text; 
    using UnorderedArrayListNamespace; 

    namespace test 
     { 
    class Program 
    { 
     static void Main(string[] args) 
     { 
      UnorderedArrayList<int> u = new UnorderedArrayList<int>(); 
      u.print(); 
      int var = 5; 
      u.insert(ref var); 
      u.insert(ref var); 
      var = 12; 
      u.insert(ref var); 
      var = 2; 
      u.insert(ref var); 
      var = 29; 
      u.insert(ref var); 
      u.print(); 
      Console.WriteLine(); 
      var = 5; 
      u.removeAll(ref var); 
      u.print(); 

      Console.WriteLine("The min value is " + u.min(ref var)); 
     } 
    } 
} 


    using System; 

    namespace ArrayListADTNamespace 
    { 
    public interface ArrayListADT<T> 
    { 
     // insert() method places one item in the list 
     void insert(ref T item); 
     // remove() method removes first instance of item in list 
     int remove(ref T item); 
     // print() method prints all items in list 
     void print(); 
     // removal all method 
     void removeAll(ref T item); 
     // min method 
     int min(ref T item); 
    } 
} 

    using System; 
    using ArrayListNamespace; 
    using ArrayListADTNamespace; 

    namespace UnorderedArrayListNamespace 
    { 
    public class UnorderedArrayList<T> : ArrayList<T>, ArrayListADT<T> 
    { 
     public UnorderedArrayList() 
     { 
     } 

     public override void insert(ref T item) 
     { 
      list[length] = item; 
      length++; 
     } 
    } 
} 

Answer 1

現在（假設您正在尋找t中的最小值他陣列）你試圖比較一個整數值到一個泛型類型T的變量。這意味着你的數組列表可能不包含有效的類型與int進行比較的值。什麼，你會想，而不是沿的

public int min(ref T item) 
{ 
    int min = 1000; 
    T tempItem = list[0]; 

    for (int i = 0; i < length; i++) 
    { 
     if (list[i].CompareTo(tempItem) < 0) 
     { 
      tempItem = list[i]; 
      min = i; 
     } 
    } 
    item = tempItem; 
    return min; 

} 

線這樣的項目引用您通過了將持有的最低項目和方法將返回最小值的索引東西。

如果你想只返回項的值試試這個：

public T min() 
{ 
    T tempItem = list[0]; 

    for (int i = 0; i < length; i++) 
    { 
     if (list[i].CompareTo(tempItem) < 0) 
     { 
      tempItem = list[i]; 
     } 
    } 
    return tempItem; 
} 

Answer 2

你的問題是，在一般情況下，你正在建設一個通用容器類，然後作出假設，一切都在你的班級是一個整數。讓我們看一下你的min方法：

public int min(ref T item) 
{   
    int min = 1000; 

    for (int i = 0; i < length; i++) 
    { 
    if (list[i] < min) 
    { 
     min = list[i]; 
    } 
    } 

    return min; 
} 

這是有道理的，如果T是數字型的，但如果你做了UnorderedArrayList<string>或UnorderedArrayList<System.Uri>或什麼？你的min函數可能會如何工作？通過與通用的參數類型你是在告訴編譯器「這個類必須與每一個都不能被創造型工作」，和廣大那些既不能轉化成也不符合一個int比較。

簡單的回答是

T min = default(T); 

更換

int min = 1000; 

然而，這兩個語句顯然不相同。同時，將默認的最小值1000編入該方法是沒有意義的：如果我給出一個例如「狗，貓，馬，牛，豬」的列表，該列表的最小值爲1000 ？

另外要注意的是，你假設你的數組中的對象，甚至可以相互比較，這不是一個安全的假設。爲了強制執行，你需要做兩件事情：

1. 約束你的類型具有可比性：

   public abstract class ArrayList<T> where T : IComparable 
   

2. 的使用IComparable方法，而不是運營商：

   if (list[i].CompareTo(min) < 0) 
   { 
       min = list[i]; 
   }