Comment initialiser char tableau de struct

comment initialiser un tableau de char dans la structure en C# je suis en train de faire ce

struct cell
{
    public char[] domain =new char[16];
    public int[] Peers;
    public int NumberOfPeers;
    public char assignValue;
}

mais sa présentation d'erreur qu'on ne peut initialiser un tableau dans le corps de la structure! peut on dire de la bonne façon

L'utilisation d'un constructeur.

OriginalL'auteur ssbb | 2012-12-17

.net arrays c#initialization struct

1

Vous pouvez utiliser un constructeur pour cela. Regardez MSDN.
```
struct cell
{
    public cell(int size)
    {
         domain = new char[size];
         this.Peers = Peers;
         this.NumberOfPeers = NumberOfPeers;
         this.assignValue = assignValue;
    }    
}
```
Comment un struct avoir un sans paramètre explcit constructeur?
Oui, vous avez raison. Il ne peut pas être sans paramètres. Mis à jour.
On dirait que vous prenez dans un "dans" paramètre (valeur de paramètre), puis immédiatement à attribuer quelque chose de nouveau à votre paramètre. C'est déroutant. Pensez également à attribuer tous les domaines.
Et maintenant, on dirait que vous êtes en assignant les trois derniers champs eux-mêmes. Mais qui ne compile pas que vous êtes en train de lire non affecté champs.

OriginalL'auteur Soner Gönül
9

Vous pouvez utiliser un constructeur
```
struct cell
{
    public cell(int charArraySize) : this()
    {
         domain = new char[arraySize];
    }

    public char[] domain;
    public int[] Peers;
    public int NumberOfPeers;
    public char assignValue;
}
```
Remarque: Même avec des structures, vous ne devriez pas avoir de champs publics mais encapsuler dans des propriétés.

Et d'être en mesure de changement les valeurs d'une structure est encore pire problème - mutable structures sont mal.

struct objets ne peuvent pas contenir sans paramètre constructeurs.
Comment un struct avoir un sans paramètre explcit constructeur?
Vous avez raison sur les propriétés, mais cela ne fait pas de compilation comme par Même et Jeppe commentaires.
Ce ne sera pas compilé. Un exemple de constructeur d'une struct attribuer tous les champs d'instance de la structure. Vous avez peut "guérir" ce que le fait de leur attribuer, ou par le "chaînage" de la (implicite) constructeur sans paramètre, comme ceci: : this()
Maintenant, la structure est légal (dans le sens qu'il compile). Mais il est encore un struct mutable par la conception. En fait, la "simple" champs de type int et char peut être utilisé uniquement par le biais de la mutation d'un déjà créé cell valeur. Mutable structs sera souvent conduire à des erreurs (en particulier pour les personnes dont les connaissances ne suffisent pas à initialiser les structures, comme l'original de l'affiche). Alors peut-être un avertissement sur les structures mutables serait pertinent dans la présente réponse.

OriginalL'auteur Oded
2

Vous pouvez (et éventuellement devez) utiliser une classe au lieu d'un struct (même si cela fait une différence, mais vous ne dites pas comment vous allez utiliser votre type).

Ou vous pouvez écrire un constructeur. Mais notez qu'une struct instance constructeur doit prendre au moins un paramètre.

Si vous vous en tenez à la structure, assurez-vous de est immuable struct. Une façon de le faire est de rendre tous les champs readonly, puis d'attribuer à eux dans votre instance constructeur.

OriginalL'auteur Jeppe Stig Nielsen
2

Une des principales limites des types de valeur .net est qu'ils ne peuvent pas contenir des tableaux, même de taille fixe, à moins que l'on quitte le domaine de la gestion de code (C# fournit un moyen d'inclure de taille fixe des tableaux à l'intérieur d'un type de la valeur à l'aide de la unsafe et fixed mots-clés, mais le code qui utilise cette capacité sera inutilisable dans certains contextes de sécurité). Ils peuvent contenir des références à des tableaux, mais si une structure contenant un tableau de référence est copiée, la copie recevoir une référence à la même matrice que l'original.

Tout semble indiquer que dans la plupart des cas, il est préférable pour une structure de type à être complètement ouvert sur ce qu'il contient (exposer l'ensemble de son etat par l'intermédiaire de champs publics) que pour faire semblant d'être autre chose qu'une collection de variables liés ensemble avec du ruban adhésif, une structure dont l'état est censé pour encapsuler l'état d'une mutable classe d'objet (comme un System.Array) doivent utiliser un modèle différent.

Si une structure est censé se comporter comme une valeur de type tableau de 64 chars, et que l'on souhaite réellement avoir les flotteurs sont stockées au sein d'un Système.Tableau plutôt que dans 64 des champs distincts, la structure doit probablement contenir un champ privé Arr de type float[]. Pour lire l'élément n, vérifiez si Arr est null. Si oui, de retour à zéro. Sinon, retourner la valeur de Arr[n]. Pour écrire élément n, définir une variable temp Arr2 à une nouvelle float[64] et copie Arr si ce n'est pas null. Puis définissez Arr2[n] à la valeur désirée, et de les remplacer Arr avec Arr2. Notez que, à la fois float[] a été stocké à Arr, il sera de nouveau ne jamais être écrite. Si une tentative est faite pour écrire à l'élément 5 de la structure, la structure reçoit un nouveau tableau avec la valeur correcte; l'élément 5 de l'ancien tableau sera intact. Par conséquent, la structure se comporte comme une valeur de type tableau doit (à l'exception de cet écrit, il sera beaucoup plus lent que d'écrire sur un tableau normal).

Si un type aura besoin d'un grand tableau, il peut être préférable d'utiliser une float[][] ou un float[][][]; par exemple, on peut tenir 4096 éléments à l'aide de 16 tableaux de les 16 tableaux de les 16 tableaux de 16 éléments. Dans ce scénario, l'écriture d'un élément à créer/copier un float[16], un float[16][], et un float[16][][]; les trois petits tableaux de la taille 16 ans peut-être mieux que deux tableaux de taille 64, et serait presque certainement être mieux qu'un tableau de taille 4096.

Valeur de type sémantique peut certainement être utile, mais comme l'a noté les structures ne peuvent pas fournir terriblement efficace si elles contiennent des tableaux. Une autre conception, si le nombre d'éléments est faible, serait tout simplement avoir un champ pour chaque élément, et ont une propriété indexée accesseur d'une instruction switch pour lire ou écrire une struct champ. Un peu dégueulasse, mais pour des structures plus petites que d'une douzaine d'éléments ou donc, il serait presque certainement être plus efficace que l'utilisation de tableaux comme décrit ci-dessus.

OriginalL'auteur supercat

essayez d'utiliser quelque chose comme ceci:

[StructLayout(LayoutKind.Sequential)]

public class TCardDB

{

public TCardDB(string strCardNo)

{

CardNo = strCardNo;

FName = LName = string.Empty;

OpenMode = FingerCount = 0;

Finger1 = new string[3];

Finger2 = new string[3];

}

..........

..........

}

OriginalL'auteur Azzy

1

Voir le premier commentaire de cette question

C# array dans une struct

Tampons De Taille Fixe - msdn.microsoft.com/en-us/library/zycewsya.aspx

Qui a fait le tour pour moi

OriginalL'auteur Sascha

Vous devez vous connecter pour publier un commentaire.