Discussion :

[Chatbour]

Bonjour à tous et à toutes

je vous donne deux constructeurs qui réalisent la même tâche :

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
class Cercle{
  private int rayon;
  private int centre_x;
  private int centre_y;
 
  Cercle(int a, int b, int c)
  {
    rayon = a;
    centre_x = b;
    centre_y = c;
  }
 
  // Voici le premier
  Cercle()
  {
    rayon = 1;
    centre_x = 0;
    cetre_y = 0;
  }
 
  /* et voici de deuxième
  Cercle()
  {
    this(1, 0, 0);
  }
  */

ma question : quel est le "meilleur".. je veux dire en termes de complexités, car à mon avis le premier fait des simples affectations, tandis que le deuxième réalise un appel procédural. Non ?

Merci d'avance..

[muad'dib]

J'aurais tendance à utiliser le 2ème qui permet d'économiser des lignes de codes. Là tu as 3 lignes dans ton constructeur, mais imagine un constructeur de 30 lignes.

[nolofinwe]

J'aurais tendance à utiliser le 2ème qui permet d'économiser des lignes de codes. Là tu as 3 lignes dans ton constructeur, mais imagine un constructeur de 30 lignes.

d'accord avec toi sur le principe mais c'est vrai que le premier est plus facile a lire...
plus compréhensible donc si tu n'a pas de constructeur tros "gros" la premiere permet peut etre une lecture plus simple du programme (par une personne autre que le programmeur par exemple)

mais bon ce n'est qu'un avis parmi d'autre

[metalpetsFR]

Salut

Me concerant :
- Concernant la complexité, je ne me préocupe jamais de savoir si une affectation est plus performante qu'un appel de procédure. Ce n'est pas pertinant de visé a "optimisé" cela. Pour moi, les seuls points critiques a optimiser sont les appels aux base de données, aux ressources distantes, à l'écriture sur le disque etc. Le reste n'apporte pas suffisament de gain (voir pas du tout)

- en ce qui concerne la lisiblité du code et même la réutilisation de code :
Si demain tu décide que ton constructeur primaire [Cercle(int,int,int)] doit en plus d'initialiser les coordonnées, effectuer d'autres opérations, ton constructeur 1 ne les prendra pas en compte, sauf si tu les recode dedans.
Le constructeur 2 est donc bien meilleur, car il ne recode pas le constructeur primaire.

[adiGuba]

Salut,

- Concernant la complexité, je ne me préocupe jamais de savoir si une affectation est plus performante qu'un appel de procédure. Ce n'est pas pertinant de visé a "optimisé" cela. Pour moi, les seuls points critiques a optimiser sont les appels aux base de données, aux ressources distantes, à l'écriture sur le disque etc. Le reste n'apporte pas suffisament de gain (voir pas du tout)

+1

Surtout qu'il y a de forte chance que le compilateur optimise ce genre d'appel...

Pour moi la seconde solution est bien plus propre car elle évite toute duplication de code... et c'est d'autant plus vrai lorsqu'il y a un très grand nombre de constructeur différents...

a++

[Sanguko]

Salut,


+1

Surtout qu'il y a de forte chance que le compilateur optimise ce genre d'appel...

Pour moi la seconde solution est bien plus propre car elle évite toute duplication de code... et c'est d'autant plus vrai lorsqu'il y a un très grand nombre de constructeur différents...

a++

+1

Cette construction est d'ailleurs tres largement utilisé dans ce que j'ai pu voir.