Membres d’instance

Une déclaration de classe correspond à un modèle ou un plan. Vous pouvez créer autant d’instances de classe que vous voulez à partir de celui-ci.

Membres d’instance : Chaque instance d’une classe est une entité indépendante, dotée de ses propres membres de données sans interférence avec les autres instances du même type. On les nomme membres d’instance car ils sont rattachés aux objets instances de la classe.

Membres statiques : Les membres d’instance sont le type par défaut. Vous pouvez aussi déclarer des membres statiques, qui appartiennent à la classe elle-même et non à ses instances. Nous aborderons ce point dans les prochains cours.

Prenons un exemple pour illustrer cela

class Program
{
    static void Main(string[] args)
    {
        Factory factoryFox = new Factory();
        Robot robot1 = new Robot();
        Robot robot2 = new Robot();
        Robot robot3 = new Robot();
    }
}

class Factory
{

}

class Robot
{
    public string name;

    public void SayHello()
    {
        Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
    }
}Langage du code : C# (cs)

Dans cet exemple, on trouve deux classes : Factory et Robot. La classe Robot contient une méthode et un champ nommé name. La classe Factory ne possède pas de champ name.

La fonction principale instancie un objet Factory et trois objets Robot.

Observons l’organisation des données en mémoire.

Les trois robots robot1, robot2 et robot3 possèdent chacun leur propre valeur name, stockée dans des emplacements mémoire distincts sans interaction. Modifier robot1 n’aura aucun effet sur robot2.

    static void Main(string[] args)
    {
        Factory factoryFox = new Factory();
        Robot robot1 = new Robot();
        Robot robot2 = new Robot();
        Robot robot3 = new Robot();

        robot1.name = "Tom"; //Chaque name est indépendant, sans influence mutuelle
        robot2.name = "Jack";
        robot3.name = "Smith";
    }Langage du code : C# (cs)

Une seule copie pour les membres de fonction

Comme vu précédemment, chaque instance dispose d’une variable name indépendante. Modifier la valeur d’une instance ne touche pas les autres. Une classe contient aussi bien des champs que des membres de fonction.

Est-ce qu’une fonction au sein d’une classe n’existe qu’en une seule copie, partagée par toutes les instances ?

Le corps du code d’une fonction (méthode) : n’existe qu’une seule fois globalement et est partagé par toutes les instances

Après compilation, les instructions machine des méthodes résident dans la table des méthodes (Method Table), propre au type. Toutes les instances de cette classe sur le tas partagent ce même code ; chaque objet ne reçoit pas sa propre copie de la fonction.

Prenons la méthode SayHello présente dans la classe Robot

class Robot
{
    public string name;

    public void SayHello()
    {
        Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
    }
}Langage du code : C# (cs)

La mémoire comporte d’autres zones en dehors du tas et de la pile. Les méthodes sont notamment stockées dans la Method Table.

Les fonctions de classe sont conservées dans la table des méthodes. Lorsqu’on appelle une fonction, le système exécute le code correspondant de cette table, celui-ci est donc partagé.

    static void Main(string[] args)
    {
        Factory factoryFox = new Factory();
        Robot robot1 = new Robot();
        Robot robot2 = new Robot();
        Robot robot3 = new Robot();

        robot1.name = "Tom";
        robot2.name = "Jack";
        robot3.name = "Smith";

        robot1.SayHello();
        robot2.SayHello();
        robot3.SayHello();
    }Langage du code : C# (cs)

Dans cet extrait, les trois appels à SayHello exécutent exactement la même fonction. Néanmoins, les variables locales de la méthode sont séparées, et l’accès aux champs dépend de l’instance appelante.

    public void SayHello()
    {
        Console.WriteLine($"Hello everyone my name is {name},I come from Foxdevelop.com");
    }Langage du code : C# (cs)

Lorsque robot1 appelle SayHello, name vaut Tom. Lorsque robot2 l’appelle, name vaut Jack, et ainsi de suite.

Membres d’instance