Est-il possible de changer la valeur par défaut d'un type de données primitif?

Question

J'ai récemment créé une matrice générique < T > classe qui agit comme une enveloppe autour d'une liste < liste < T > > collection. Autant que je sache, cette classe fonctionne parfaitement. Je rencontre un léger problème en ce qui concerne les valeurs par défaut des T.

Je crée une instance de Matrix < int > (3, 3), qui crée une matrice 3x3 d’entités, toutes réinitialisées à 0 avec la valeur par défaut (T). Je sais que les types de valeur (qui incluent les primitives) ont un équivalent égal à 0 et que les types de référence ont la valeur null. Je me demandais s’il était possible de changer cette valeur par défaut de sorte que si un type de valeur est passé dans la matrice, il serait rempli de 5 par exemple, au lieu de 0.

J'ai essayé de créer ma propre structure (type valeur), mais, ne pouvant pas utiliser de constructeurs sans paramètre dans les structures, je ne trouve pas le moyen de modifier la valeur par défaut à partir de 0.

Je suppose que la modification de la valeur par défaut n’est pas possible, et je devrai parcourir la matrice Matrix après son instanciation, mais je voulais poser la question ici au cas où je le ferais auparavant.

Answer 1

 public Matrix(int width, int height) : this(width, height, default(T)) {}
 public Matrix(int width, int height, T defaultValue)
 {
     List<T> rows = new List<T>(height);
     for (int i = 0; i < height; i++)
     {
         List<T> columns = new List<T>(width);
         for (int j = 0; j < width; j++)
         { columns.Add(defaultValue); }
         rows.Add(columns);
     }
     // store `rows` wherever you are storing it internally.
 }

Mais comme le dit Joseph, il n’ya aucun moyen de définir ce à quoi default(T) est évalué.

Answer 2

Il n'y a aucun moyen de changer la valeur par défaut, comme vous le décrivez.

var someInt = default(int); //this will always be 0, you can't change it
var someReference = default(SomeClass); //this will always be null

Voici un article msdn dessus. , bien que ce ne soit pas beaucoup plus descriptif que ce qui a déjà été dit malheureusement.

Answer 3

Vous pouvez créer une structure qui encapsule sa valeur et l'expose uniquement avec un décalage de la valeur par défaut souhaitée:

public struct DefaultFiveInteger {

   private int _value;

   public DefaultFiveInteger(int value) {
      _value = x - 5;
   }

   public static implicit operator int(DefaultFiveInteger x) {
      return x._value + 5;
   }

   public static implicit operator DefaultFiveInteger(int x) {
      return new DefaultFiveInteger(x);
   }

}

Vous pouvez maintenant déclarer une variable initialisée à la valeur par défaut (0) et renvoyer la valeur avec le décalage:

DefaultFiveInteger x;
Console.Write(x);

Sortie:

5

Answer 4

Etant donné que vous examinez déjà les structures, vous pouvez simuler une valeur par défaut comme suit:

public struct MyInt
{
    private int _defaultInt;
    public int DefaultInt
    {
        get
        {
            if (_defaultInt == 0)
                return 5;
            else
                return _defaultInt;
        }
        set
        {
            _defaultInt = value;
        }
    }
}

Answer 5

D'après ce que je comprends de l'implémentation de default(T), le moteur d'exécution, par défaut, met la mémoire à zéro à la demande de l'application, et C # alloue simplement de l'espace sans jamais écraser les zéros. Il se trouve que les valeurs par défaut des types non numériques (par exemple, la référence null, false) sont représentées sous forme de zéros dans la mémoire. Cela peut conduire à un comportement étrange; Par exemple, default(MyEnumType) sera égal à zéro même si vous n'avez jamais spécifié qu'une valeur enum soit égale à zéro.

Answer 6

En combinant les idées de Guffa et de DougJones, vous pouvez compenser un membre partenaire de propriétés.

public struct MyInt
{
    private const int INT_DEFAULT = 5;
    private int _defaultInt;
    public int DefaultInt
    {
        get { return _defaultInt + INT_DEFAULT; }
        set { _defaultInt = value - INT_DEFAULT; }
    }
}