Listes d'initialisation de constructeurs longs

Question

Comment les traitez-vous? J'ai quelques classes (généralement des classes qui contiennent des stats, etc.) avec plus de 20 membres variables, et les listes d'initialisation se terminent très longtemps, dépassant la largeur de la page si je ne les entoure pas manuellement. Essaies-tu de briser ces classes ou est-ce que tu t'occupes d'une autre façon?

Il ne semble pas très bien rangé, mais parfois j'écrire les variables dans la liste au-dessus de l'autre comme ceci:

myConstructor(var1, var2, var3, ..., varN) : 
member1(var1), 
member2(var2), 
member3(var3), 
... 
memberN(varN) 

Answer 1

allant au-delà de la largeur de la page

bien Tout d'abord, vous devriez probablement décider de la largeur d'une page et s'y tenir. Utilisez l'enrubannage automatique de votre éditeur, si vous le souhaitez. La lecture d'un code supérieur à la taille de votre fenêtre est vraiment difficile, surtout pour vos collègues utilisant des terminaux vi ou emacs. Choisissez une largeur de page et respectez-la, ce qui revient à envelopper ces listes d'initialisation sur plusieurs lignes (peut-être plusieurs).

Essayez-vous de répartir ces classes?

20 est beaucoup de paramètres, il mérite probablement d'être brisé. Les «classes de Dieu» sont généralement une odeur de code et indiquent qu'un refactoring est nécessaire.

Cela ne signifie pas automatiquement que vous devriez casser les choses, il y a toujours des exceptions aux directives. Mais, définitivement, considérez cela comme une option. Lorsque vous les déclarez dans le fichier d'en-tête, les groupez-vous (ou pourriez-vous les grouper) avec des commentaires? Par exemple: // These next few parameters are for file IO et // These next parameters are for the widget, qui vous fournira un bon modèle pour les objets qui cherchent à être abstraits.

En général, les classes très volumineuses indiquent beaucoup d'état compliqué, et un état compliqué a tendance à causer des bogues. Vous devriez, comme avec les fonctions, préférez les garder petites et concentrées.

{Votre code exemple}

Je pense est tout à fait lisible et « bien rangé », bien qu'il sera probablement assez longue liste. Comme je l'ai mentionné, pour lutter contre cela, je envisagerais de le diviser en classes plus petites.

Answer 2

Toute classe avec vingt arguments constructeur doit probablement être refactorisée. J'envisagerais d'utiliser composition, en décomposant les grandes classes en morceaux plus petits et indépendants. Pensez aux arguments de vos constructeurs qui sont étroitement liés et regroupez ces variables dans leur propre classe. Vous pouvez ensuite transmettre une instance de votre nouvelle classe aux classes qui ont besoin d'accéder aux données.

Answer 3

les listes d'initialisation finissent très long, allant au-delà de la largeur de la page, si je ne pas enrouler manuellement autour

Une façon consiste à factoriser: par exemple, au lieu de passer en 4 variables primitives ("top", "left", "width" et "height"), passez simplement dans une variable composée ("rectangle").

Sinon, il suffit de le faire avec la mise en page du code source:

class Foo 
{ 
    int m_a; 
    int m_b; 
    int m_c; 
public: 
    Foo(
     int a, 
     int b, 
     int c 
     ) 
     : m_a(a) 
     , m_b(b) 
     , m_c(c) 
    { 
    } 
};