Discussion :

[new_wave]

Bonjour,

En quoi est il utile d'appeler un constructeur de plusieurs paramètres dans un constructeur par défaut

pour une classe donnée.

Si , au niveau de cette classe, je définis un constructeur de plusieurs paramètres sans définir de constructeur par défaut,

c'est ce constructeur à 4 paramètres qui devient le constructeur par défaut.

Dans quel cas peut on avoir besoin, en effet, d'un constructeur par défaut (sans paramètres) qui s'appuie pour sa construction, sur un constructeur avec paramètres?

Merci beaucoup de votre réponse.
Cordialement.

new_wave

Voici un exemple de code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
class Residence
    {
        public ResidenceType type;
        public int numberOfBedrooms;
        public bool hasGarage;
        public bool hasGarden;
 
       //constructeur avec 4 paramètres
 
 
 
        public Residence(ResidenceType type, int numberOfBedrooms, bool hasGarage, bool hasGarden)
        {
            this.type = type;
            this.numberOfBedrooms = numberOfBedrooms;
            this.hasGarage = hasGarage;
            this.hasGarden = hasGarden;
 
        }//fin de 1er constructeur
 
 
        //constructeur sans paramètres et usage du mot clé this
        public Residence(): this(ResidenceType.House, 3, true, true) { }
 
    }//fin de classe
 
}//fin de namespace

[neilbgr]

Si , au niveau de cette classe, je définis un constructeur de plusieurs paramètres sans définir de constructeur par défaut, c'est ce constructeur à 4 paramètres qui devient le constructeur par défaut.

La notion de "constructeur par défaut" ne survient uniquement lorsqu'une classe n'a aucun constructeur de définit. Aussi, ce "constructeur par défaut" n'a aucun paramètre.

Dès qu'au moins un constructeur (avec ou sans paramètre) est définit dans un classe, et quelque soit la visibilité (public, protected, private) de ce constructeur, on ne peut plus dire qua la classe a un "constructeur par défaut" car (je me répète) celui-ci est seulement généré automatiquement si aucun constructeur n'est définit.

Est-ce plus clair ainsi ?

[DonQuiche]

En quoi est il utile d'appeler un constructeur de plusieurs paramètres dans un constructeur par défaut

D'abord à faire des économies de code : tu n'as eu qu'à prolonger une ligne au lieu d'en rajouter 4.

Et puis ton exemple est assez simple mais certains constructeurs peuvent réaliser des initialisations complexes et il est préférable de réutiliser ce code plutôt que de le dupliquer. D'où l'intérêt de permettre à un constructeur d'en appeler un autre : économie de code et moins de risques de bogues (N lignes à vérifier et modifier au lieu de 2N).

[new_wave]

La notion de "constructeur par défaut" ne survient uniquement lorsqu'une classe n'a aucun constructeur de définit. Aussi, ce "constructeur par défaut" n'a aucun paramètre.

Dès qu'au moins un constructeur (avec ou sans paramètre) est définit dans un classe, et quelque soit la visibilité (public, protected, private) de ce constructeur, on ne peut plus dire qua la classe a un "constructeur par défaut" car (je me répète) celui-ci est seulement généré automatiquement si aucun constructeur n'est définit.

Est-ce plus clair ainsi ?

Bonjour et merci de ta réponse.
Il se trouve que dans le cours diffusé par Microsoft, on considère qu'un constructeur sans paramètre est un constructeur par défaut.

Voici ce qui est écrit

It is also possible to call one constructor from another by using the this keyword as part of the constructor declaration.
The constructor with the matching signature will be run.
Using this feature, you can implement a default constructor that calls a parameterized constructor with a set of default values for each parameter, as shown in the following code example
Si j'ai bien compris, le constructeur par défaut dont il est question est celui sans paramètre montré dans l'exemple ci-dessous.

J'aimerais bien que les choses soient claires sur ce point afin qu'il n'y ait pas confusion.

Te remerciant beaucoup de ta réponse à ce sujet.

Bien cordialement.

new_wave

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
 
        class Residence
            {
                public ResidenceType type;
                public int numberOfBedrooms;
                public bool hasGarage;
                public bool hasGarden;
 
               //constructeur avec 4 paramètres
 
 
 
                public Residence(ResidenceType type, int numberOfBedrooms, bool hasGarage, bool hasGarden)
                {
                    this.type = type;
                    this.numberOfBedrooms = numberOfBedrooms;
                    this.hasGarage = hasGarage;
                    this.hasGarden = hasGarden;
 
                }//fin de 1er constructeur
 
 
                //constructeur sans paramètres et usage du mot clé this
                public Residence(): this(ResidenceType.House, 3, true, true) { }
 
            }//fin de classe
 
        }//fin de namespace

[new_wave]

D'abord à faire des économies de code : tu n'as eu qu'à prolonger une ligne au lieu d'en rajouter 4.

Et puis ton exemple est assez simple mais certains constructeurs peuvent réaliser des initialisations complexes et il est préférable de réutiliser ce code plutôt que de le dupliquer. D'où l'intérêt de permettre à un constructeur d'en appeler un autre : économie de code et moins de risques de bogues (N lignes à vérifier et modifier au lieu de 2N).

Merci de ta réponse.

En fait, ce que je n'avais pas bien réalisé, c'est qu'après avoir fait appel à un constructeur déjà existant au niveau du constructeur sans paramètre, on peut ajouter des initialisations entre les {}; ceci permet en effet de ne pas dupliquer de code .

Merci à toi.
Bien cordialement.

new_wave

[neilbgr]

Sans vouloir imiter Jean-Michel Relou, Microsoft nous dit:

Si une classe ne contient pas de déclaration de constructeur d'instance, un constructeur d'instance par défaut lui est fourni automatiquement. Ce constructeur par défaut ne fait qu'appeler le constructeur sans paramètre de la classe de base directe

Sache également que le constructeur sans paramètre (que tu nommes à tord "par défaut", JM Relou, sort de ce corps ! ) n'est pas obligatoire sauf rares cas (Serialization XML, Type générique avec contrainte new()).

Je ne veux pas jouer sur les mots, mais un peu de rigueur avec ces derniers évite pas mal de discorde.

Tu peux aussi rendre optionnels tous les paramètres de ton constructeur ainsi :

Code C# :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
            class Residence
            {
                public ResidenceType type;
                public int numberOfBedrooms;
                public bool hasGarage;
                public bool hasGarden;
 
                public Residence(ResidenceType type = ResidenceType.House, int numberOfBedrooms = 3, bool hasGarage = true, bool hasGarden = true)
                {
                    this.type = type;
                    this.numberOfBedrooms = numberOfBedrooms;
                    this.hasGarage = hasGarage;
                    this.hasGarden = hasGarden;
 
                }
 
            }//fin de classe
 
            static class Program
            {
                        public static void Main()
                        {
                                    var Toto1 = new Residence(ResidenceType.Building, 3, true, true);
                                    var Toto2 = new Residence(ResidenceType.Building, 3, true);
                                    var Toto3 = new Residence(ResidenceType.Building, 3);
                                    var Toto4 = new Residence(ResidenceType.Building);
                                    var Toto5 = new Residence();
                                    // Toutes ces instances ont leurs propriétés avec la même valeur.
 
                                    // Avec les paramètres nommés :
                                    var TotoA = new Residence(numberOfBedrooms: 5);
                                    var TotoB = new Residence(hasGarden: false, hasGarage: false);
 
                                    // Enfin une dernière syntaxe dont je n'ai pas le nom :
                                    var TotoC = new Residence() { numberOfBedrooms = 4 };
                        }
            }

[new_wave]

Bonjour et merci de ta réponse.

La définition que tu proposes, ci-dessous, d'un constructeur par défaut, est tout à fait recevable.

Si une classe ne contient pas de déclaration de constructeur d'instance, un constructeur d'instance par défaut lui est fourni automatiquement. Ce constructeur par défaut ne fait qu'appeler le constructeur sans paramètre de la classe de base directe

Il est clair que si une classe n'a pas été définie avec un constructeur, un constructeur par défaut et sans paramètre lui est fourni automatiquement.
Mais si jun constructeur a été défini pour une classe , et que celui ci est sans paramètre, d'après la définition de Microsoft, en anglais, ce constructeur est considéré comme "default constructor".
C'est là, d'après toi, qu'il y a erreur.

La définition de Microsoft en français proposée ci-dessus ne contredit pas forcément la possibilité d'existence d'un constructeur par défaut autre que celui qui existe quand aucun constructeur n'a été défini.

Pour ma part, tout ce que je veux savoir de manière claire est si oui ou non la définition de Microsoft en anglais est recevable .

It is also possible to call one constructor from another by using the this keyword as part of the constructor declaration.
The constructor with the matching signature will be run.
Using this feature, you can implement a default constructor that calls a parameterized constructor with a set of default values for each parameter, as shown in the following code example

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 
 class Residence
                    {
                        public ResidenceType type;
                        public int numberOfBedrooms;
                        public bool hasGarage;
                        public bool hasGarden;
 
                       //constructeur avec 4 paramètres
 
 
 
                        public Residence(ResidenceType type, int numberOfBedrooms, bool hasGarage, bool hasGarden)
                        {
                            this.type = type;
                            this.numberOfBedrooms = numberOfBedrooms;
                            this.hasGarage = hasGarage;
                            this.hasGarden = hasGarden;
 
                        }//fin de 1er constructeur
 
 
                        //constructeur sans paramètres et usage du mot clé this
                        public Residence(): this(ResidenceType.House, 3, true, true) { }
 
                    }//fin de classe
 
                }//fin de namespace

Pour ce qui est du dernier exemple que tu as donné ,

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
var TOTOC = new Residence(){ numberOfBedrooms = 4};

Il s'agit d'un initializer qui remplace la valeur 3 affectée par défaut à la variable numberOfBedrooms .

Cordialement.

new_wave