1

这个问题由 4 个不同的类组成。问题是：

  1. 运算符“<”不能应用于“T”和“int”类型的操作数。
  2. 无法将类型“T”隐式转换为“int”。这是在 min 方法中。

在我看来， list[i] 是我需要比较的具体内容。如果我删除列表 [i] 并用它替换它只i会给我 1000。如果我删除if (item.Equals(list[i]))它给我 0。

但是我可以将数字添加到该整数中，如果该数字大于最小值（为 2），它会识别或看到数字 2。最后一部分可能没有多大意义，也很难解释。

我可以比较什么或如何给我最小整数？我错过了什么小东西还是很大的东西？list[i] 是我需要比较的吗？

我仍然遇到的问题是，当我尝试进行比较时，它不能识别 T在类参数中）

我想也许

    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++;
        }
    }
}
4

2 回答 2

3

您遇到的问题是，通常，您正在构建一个通用容器类，然后假设您的类中的所有内容都是整数。让我们看看你的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，也不能与 int 进行比较。

快速的答案是更换

int min = 1000;

和

T min = default(T);

然而，这两种说法显然不相同。同时，将默认最小值 1000 编码到方法中是没有意义的：如果我给你一个列表，比如“狗、猫、马、牛、猪”，那么该列表的最小值 1000 ?

要注意的另一件事是，您假设数组中的对象甚至可以相互比较，这不是一个安全的假设。为了强制执行，您需要做两件事：

  1. 将您的类型限制为具有可比性：

    public abstract class ArrayList<T> where T : IComparable

  2. 使用IComparable's 方法而不是运算符：

    if (list[i].CompareTo(min) < 0)
{
  min = list[i];
}
于 2013-09-23T22:38:42.640 回答
2

现在（假设您正在寻找数组中的最小值）您正在尝试将整数值与泛型类型 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;
}
于 2013-09-23T22:40:19.323 回答