D.R.Y vs "avoid macros"

Question

I am creating my own implementation of XUL in C++ using the Windows API. The fact that the elements are constructed by the XML parser requires that they have identical interfaces, so that we don't need to write custom code for each element constructor. The result is that most of my elements look like this: ``` class Button : public Element { public: static const char * Type() { return "button"; } private: friend class Element; Button(Element * inParent, const AttributesMapping & inAttributesMapping); }; class Label : public Element { public: static const char * Type() { return "label"; } private: friend class Element; Label(Element * inParent, const AttributesMapping & inAttributesMapping); }; class Description : public Element { public: static const char * Type() { return "description"; } virtual bool init(); private: friend class Element; Description(Element * inParent, const AttributesMapping & inAttributesMapping); }; ``` So there is a lot of code duplication here. I wonder if it…

Accepted Answer

I would not use a macro here. The clue is in your class "Description", which has an extra member function `init`, which the others don't. So you wouldn't be able to use the macro to define it, but you'd instead expand the macro manually and add the extra line.

To me, this is a bigger violation of DRY than just writing out all the class definitions. Almost not repeating yourself, but doing it just for one case, often ends up harder to maintain that repeating yourself consistently. DRY is about finding good abstractions, not just cutting down on boilerplate.

I might replace those constructors, though, with a `SetAttributes` function in class `Element`. That might cut the amount of boilerplate actually required in each derived class, since constructors are the one thing that can't be inherited from the base. But it depends how similar the implementations are of the constructor of each class.

D.R.Y vs "avoid macros"

Solution

Problem