una - ¿hay en C#un método para la lista<T> como cambiar el tamaño en c++ para el vector<T>

matrices en c ejemplos

Question

Cuando uso resize(int newsize) en C ++ para el vector<T> , significa que el size de este vector está configurado para newsize y los índices se ejecutan en el rango [0..newsize) . ¿Cómo hacer lo mismo en C # para la List<T> ?
Cambiar la propiedad de la List<T> Capacity solo cambia la Capacity pero deja la Count igual y, además, los índices aún están en el rango [0..Count) . Ayúdame, por favor.

PS Imagine que tengo un vector<T> tmp con tmp.size() == 5 No puedo referirme a tmp[9] , pero cuando uso tmp.resize(10) puedo referirme a tmp[9] . En C # si tengo la List<T> tmp con tmp.Count == 5 no puedo referirme a tmp[9] ( IndexOutOfRangeException ), pero incluso cuando establezco tmp.Capacity=10 no podré referirme a tmp[9] coz de tmp.Count sigue siendo 5. Quiero encontrar alguna analogía de cambio de tamaño en C #.

Answer 1

Esta es mi solución.

private void listResize<T>(List<T> list, int size)
{
   if (size > list.Count)
      while (size - list.Count > 0)
         list.Add(default<T>);    
   else if (size < list.Count)
      while (list.Count - size > 0)
         list.RemoveAt(list.Count-1);
}

Cuando el size y la list.Count son iguales, no es necesario cambiar el tamaño de la lista.

El parámetro default(T) se usa en lugar de null , "" , 0 u otros tipos anulables, para llenar un elemento vacío en la lista, porque no sabemos qué tipo <T> es (referencia, valor, estructura, etc.). ).

PD: utilicé bucles en lugar de bucles while y me encontré con un problema. No siempre el tamaño de la lista era lo que estaba pidiendo. Era más pequeño. ¿Alguna idea de por qué?

Revisalo:

private void listResize<T>(List<T> list, int size)
{
   if (size > list.Count)
      for (int i = 0; i <= size - list.Count; i++)
         list.Add(default(T));
   else if (size < list.Count)
      for (int i = 0; i <= list.Count - size; i++)
         list.RemoveAt(list.Count-1);
}

Answer 2

No has leído en MSDN:

Una lista es una colección de elementos de tamaño variable . Las listas se pueden construir de múltiples maneras, pero la clase más útil es la Lista. Esto le permite escribir con firmeza su lista, incluye todas las funciones esenciales para tratar con colecciones y se puede buscar fácilmente.

Promover:-

Capacidad es el número de elementos que la Lista puede almacenar antes de que se requiera el cambio de tamaño, mientras que Contar es el número de elementos que realmente están en la Lista.

La capacidad es siempre mayor o igual a Count. Si el conteo excede la capacidad al agregar elementos, la capacidad se incrementa al reasignar automáticamente la matriz interna antes de copiar los elementos antiguos y agregar los nuevos elementos .

Answer 3

No, pero puedes usar métodos de extensión para agregar los tuyos. Lo siguiente tiene el mismo comportamiento que std::vector<T>::resize() , incluida la misma complejidad de tiempo. La única diferencia es que en C ++ podemos definir un void resize ( size_type sz, T c = T() ) predeterminado con void resize ( size_type sz, T c = T() ) y la forma en que funcionan las plantillas significa que está bien si lo llamamos sin el valor predeterminado para una T que no tiene parámetros accesibles. constructor. En C # no podemos hacer eso, así que tenemos que crear un método sin restricciones que coincida con el caso que no se usa por defecto, y otro con una restricción where new() llama a eso.

public static class ListExtra
{
    public static void Resize<T>(this List<T> list, int sz, T c)
    {
        int cur = list.Count;
        if(sz < cur)
            list.RemoveRange(sz, cur - sz);
        else if(sz > cur)
        {
            if(sz > list.Capacity)//this bit is purely an optimisation, to avoid multiple automatic capacity changes.
              list.Capacity = sz;
            list.AddRange(Enumerable.Repeat(c, sz - cur));
        }
    }
    public static void Resize<T>(this List<T> list, int sz) where T : new()
    {
        Resize(list, sz, new T());
    }
}

Ahora, los gustos de myList.Resize(23) o myList.Resize(23, myDefaultValue) coincidirán con lo que uno espera del vector de C ++. Sin embargo, me gustaría señalar que a veces con C ++ tendrías un vector de punteros, en C # tendrías una lista de algún tipo de referencia. Por lo tanto, en los casos en que C ++ T() produce un puntero nulo (porque es un puntero), aquí esperamos que se llame un constructor sin parámetros. Por esa razón, podría encontrarlo más cerca del comportamiento al que está acostumbrado a reemplazar el segundo método con:

  public static void Resize<T>(this List<T> list, int sz)
  {
      Resize(list, sz, default(T));
  }

Esto tiene el mismo efecto con los tipos de valor (llamar al constructor sin parámetros), pero con los tipos de referencia, se llenará con valores nulos. En cuyo caso, podemos reescribir toda la clase para:

public static class ListExtra
{
    public static void Resize<T>(this List<T> list, int sz, T c = default(T))
    {
        int cur = list.Count;
        if(sz < cur)
            list.RemoveRange(sz, cur - sz);
        else if(sz > cur)
            list.AddRange(Enumerable.Repeat(c, sz - cur));
    }
}

Tenga en cuenta que no se trata tanto de las diferencias entre std::vector<T> y List<T> como de las diferencias en la forma en que se utilizan los punteros en C ++ y C #.

Answer 4

Solo para hacer más legible la respuesta de Jon Hanna :

public static class ListExtras
{
    //    list: List<T> to resize
    //    size: desired new size
    // element: default value to insert

    public static void Resize<T>(this List<T> list, int size, T element = default(T))
    {
        int count = list.Count;

        if (size < count)
        {
            list.RemoveRange(size, count - size);
        }
        else if (size > count)
        {
            if (size > list.Capacity)   // Optimization
                list.Capacity = size;

            list.AddRange(Enumerable.Repeat(element, size - count));
        }
    }
}

Answer 5

Una lista no tiene un tamaño finito.

¿Hay alguna razón por la cual el tamaño te importa?

Tal vez una matriz o un diccionario está más cerca de sus requerimientos

Answer 6

lo siento. ¿Es esto lo que necesitas? List.TrimExcess()

Answer 7

List<T>.Capacity configuración List<T>.Capacity es como usar std::vector<T>.reserve(..) . Tal vez la List<T>.AddRange(..) ajuste a sus necesidades.