Discussion :

[cescu]

Bonjour,

je viens ici pour demander de l'aide à propos de la surcharge de constructeur.
Je suis sur un site qui me semble un bon cours pour ma compréhension du C# POO. Je me suis donc inspiré d'un exemple existant pour illustrer quelque chose que je n'arrive pas à comprendre. Dans l'exemple ci-dessous j'instancie l'objet Chien de 2 façons Chien chien1 = new Chien() et Chien chien2 = new Chien("chien1"). Dans le premier j'obtiens les résultats que je souhaite donc car pour moi un chien1 est construit d'abord en tant qu'Animal sans argument puis en tant que Chien sans argument. PAr contre je ne comprends pas pourquoi pour l'objet chien2 j'ai le résultat un animal vient d'être créé sans argument et un nouveau chien vient d'être créé avec la variable chien2. Je m'attendais à voir d'abord : Un animal chien2 vient d'être créé !!! puis un nouveau chien vient d'être créé avec la variable chien2.
J'espère avoir été clair dans la façon d'expliquer mon problème. Merci.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
 
using System;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Chien chien1 = new Chien();
            Chien chien2 = new Chien("chien2");
        }
    }
 
    class Animal
    {
        public string v1;
 
        /**
         * constructeur de notre classe animal
         */
        public Animal()
        {
            Console.Out.WriteLine("Un animal vient d'être créé sans argument");
        }
 
        public Animal(string nomVariable)
        {
            Console.Out.WriteLine("Un animal" + nomVariable + " vient d'être créé !!!");
            this.v1 = nomVariable;
        }
      }
 
 
    class Chien : Animal
    {        
        public Chien()
        {
            Console.Out.WriteLine("un nouveau chien sans argument vient d'être créé");
        }
 
        public Chien(string nomVariable)
        {
            Console.Out.WriteLine("un nouveau chien vient d'être créé avec la variable " + nomVariable);
        }
 
    }
}

[StormimOn]

Lorsque tu instancies un objet dérivé il y a toujours un appel à un des constructeurs de la classe parent.

Cet appel est soit implicite, le constructeur par défaut de la classe parent est alors utilisé

Code :

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

1
2
3
4
public Chien()
{
    ...
}

Revient à écrire

Code :

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

1
2
3
4
public Chien() : base()
{
    ...
}

Le mot clé base permettant d'indiquer le constructeur de la classe parent à utiliser pour l'instanciation.

Soit explicite, dans ce cas on indique le constructeur de la classe parent à utiliser

Code :

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

1
2
3
4
public Chien(string nomVariable) : base(nomVariable)
{
    ...
}

[cescu]

merci Je ne connaissais pas ce mot clé et son utilisation. Miantenant mon programme exemple fonctionne correctement.

Merci pour tes explications.

[harz62]

Tu peux appeler le constructeur de la classe mère mais tu peux aussi appeler les constructeurs surchargés ou non de ta classe avec le mot clé this

Exemple:

Code :

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

1
2
3
4
5
6
 
//Ce constructeur appellera explicitement  le constructeur Chien() de la même classe avec d'exécuter ses instructions.
public Chien(string chaine) : this()
{
 
}

[cescu]

Merci Harz,

c'est un aspect que je n'ai pas trouvé dans le cours que j'utilise.
A+

[batbaille]

Je relance le sujet par une nouvelle question : peux t on avoir les deux en même temps (this & base) dans la surcharge d'un constructeur ?

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
public class A
{
   A()
   A(int i):this()
   A(int i, int j):this(i)
}
 
public class B : A
{
   B()
   B(int k):this() & base()
   B(int k, int l):this(k) & base(k)
}

[olibara]

Essayer soi meme peut aussi aider et est parfois plus rapide que de poser la question et attendre la reponse

[batbaille]

Tout à fait et je ne suis pas arrivé à trouver la syntaxe. C'est bien pour cela que je pose la question.

Du coup, afin d'avoir une confirmation dans un sens ou dans l'autre et de ne pas rester sur un doute, je souhaitais demander à la communauté si ce moyen existe ou pas.

[olibara]

Qu'est ce que tu veux faire exactement ?

[batbaille]

La question est : Depuis un constructeur surchargé d'une classe dérivée, peut on appeler un autre constructeur de la classe dérivée ET également un constructeur de la classe de base.

Exemple parlant :

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
30
31
32
33
34
35
36
37
38
39
40
// Classe de base A
public classe A
{
    // Ayant deux attributs
    public readonly int a1;
    public int a2;

    // Le 1er initialisé dans le constructeur par défaut
    public A()
    {
      this.a1= 10;
    }

    // Le 2eme initialisé dans le constructeur avec argument
    // et qui fait appel au constructeur par défaut
    public A(int a2):this()
    {
      this.a2= a2;
    }
}

// Classe B dérivée de la classe A
public classe B : A
{
    // Un seul argument
    public readonly int b1;

    // Initialisé dans le constructeur par défaut
    public B()
    {
      this.b1= 11;
    }
    // Un consctructeur avec argument qui appelle le constructeur par défaut
    // et le constructeur de base avec un argument
    // Attention cette syntaxe ne fonctionne pas
    public B(int b2):this(), base(b1)
    {      
    }
}

Le but est de savoir si on peut faire ce double appel afin d'éviter de dupliquer du code dans un constructeur donné. C'est juste une question de culture.

[MaximePalmisano]

J'ai déjà cherché, et voyant que ce n'était pas apparemment possible, suis mis à me poser des questions. Au final, cela relève un peu d'un problème de conception. Il suffit de faire :

Code :

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

1
2
3
4
5
6
7
8
 
public A() : base()
{
}
 
public A(string s) : this()
{
}

Du coup, A(string s) appelle indirectement base().

[Titsta]

Bon, j'ai buté sur ce problème, car la solution proposé ne permet pas de résoudre certains cas, où il est nécessaire d'appeler le constructeur au milieu ou à la fin et non pas au début.

La solution que j'ai trouvé, c'est poser le contenu des constructeurs dans des méthodes protected du style :

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
 
 
public class ClassA
{
    public ClasseA() { construct(); }
    public ClasseA(typeA a, typeB b,typeC c) : this() { construct(a,b,c); }
 
    protected void construct()
    {
    // Mon code de constructeur vide
    }
 
    protected void construct(typeA a, typeB b,typeC c)
    {
    // Mon code de constructeur avec arguments
    }
 
}

Ce qui permet dans une classe B de l'appeler au sein même du constructeur.
Ou d'appeler éventuellement plusieurs constructeurs différents.
Ou, pour le cas qui m'embétait, appeler le constructeur avec des données travaillées.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
public class ClasseB : ClasseA
{
    public ClasseB : base() // Appel du constructeur vide de A initial
    {
    // Début de constructeur classe B (ex : fabrication des arguments)    
 
    base.construct(a,b,c);
 
    // Fin de constructeur classe B
    }
 
}

C'est pas extraordinairement élégant, puisqu'on pourrait potentiellement appeller un constructeurs au sein même d'autres méthodes...
(alors que je préfèrerai parfois laisser le code des constructeurs uniquement au sein d'un constructeurs)

Mais ça permet de faire à peu près ce qu'on veux, en se payant même le luxe de laisser private les propriétés private de A qu'on souhaitait modifier lors de la construction.

Note :
Il est nécessaire de redéfinir chaque méthode construct avec un new à chaque échelon.

Et il est conseillé de bloquer l'héritage des constructeurs de A dans B.
Pour éviter qu'une ClasseC héritant de ClasseB utilise malencontreusement un constructeur de A en pensant utiliser un de B...

C'est ces contraintes qui font que c'est moyennement propre comme technique. ça peut entrainerdes bug si on fait pas gaffe.

L'aventage de la méthode, c'est que tous les constructeurs de A peuvent être posé l'un en dessous de l'autre chacun sur une ligne.
Ce qui (je trouve) rend beaucoup plus clair la comparaison entre les différents constructeurs accessible au sein de la classe. (surtout si on en a 5 ou 6)

Un autre aventage, c'est qu'on peut aussi du coup poser au sein des interfaces les indications sur les constructeurs à construire pour chacun des éléments.

[landry161]

public A() : base()
{
}

c est de l héritage

[landry161]

public A() : base()
{
}

Notion d' héritage dans le concept de la POO