9. Structures

Une structure est similaire à une classe, avec les principales différences suivantes :

Une classe est un type référence, tandis qu'une structure est un type valeur. En conséquence, les structures sont typiquement utilisées pour exprimer des types simples, dans lesquels la sémentique de type valeur est désirable (c-à-d qu'une assignation copie une valeur plutôt qu'une référence).
Une classe supporte pleinement l'héritage, tandis qu'une structure ne peut hériter que d'un objet implicitement scellé (sealed) (dans l'environnement d'exécution, les structures héritent en fait de System.ValueType. Les classes est les structures peuvent implémenter des interfaces.
Une classe peut avoir un destructeur, une structure ne peut pas.
Une classe peut définir un constructeur sans paramètres et initialiser des instances de champs, alors qu'une structure ne peut pas. le constructeur sans paramètre par défaut pour une structure initialise chaque champ avec une valeur par défaut (en fait 0). Si une stucture déclare un (des) constructeur(s), alors tous ses champs doivent être assignés dans cet appel de constructeur.

Voici une déclaration de structure (struct) simple :

struct Point
{
    // champs
    public int x, y;
}

Et voici un exemple un peut plus complet :

Code

Résultat

Remarques

using System;

namespace Exemples
{
    struct Point
    {
        // champs
        public string nom;
        public int x, y;

        // constructeur
        public Point(string nom, int x, int y)
        {
            this.nom = nom;
            this.x = x;
            this.y = y;
        }

        // méthode
        public void AffichePoint()
        {
            Console.WriteLine(nom + "(" + x +", " + y + ")");
        }
    }
    class Structures
    {
        static void Main(string[] args)
        {
            // utilisation du constructeur par défaut
            Point p1 = new Point();
            p1.AffichePoint(); // affiche (0, 0)
            // utilisation du constructeur avec 3 arguments
            Point p2 = new Point("P2", 33, 33);
            p2.AffichePoint(); // affiche P2(33, 33)
            Point p3;
            // initialisation sans constructeur
            p3.nom = "P3";
            p3.x = 33;
            p3.y = 91;
            p3.AffichePoint(); // affiche P3(33, 91)
            // tableau de structures
            Point[] points = new Point[3];
            points[0] = p1;
            points[1] = p2;
            points[2] = p3;
            foreach (Point p in points)
                p.AffichePoint(); // affiche tout ce qui a été affiché avant...
            Console.ReadKey();
        }
    }
}

(0, 0)
P2(33, 33)
P3(33, 91)
(0, 0)
P2(33, 33)
P3(33, 91)

Pour créer une structure, vous pouvez utiliser l'opérateur new qui initialisera tous les membres de la structure. Si vous n'utilisez pas l'opérateur new, vous devrez initialiser les membres de la structure vous-même. Vous pouvez également utiliser la syntaxe de déclaration de tableau pour créer un tableau de structures.

Pour plus d'information :
ValueType, classe : http://msdn.microsoft.com/fr-fr/library/system.valuetype.aspx