Automatically generate constructors based on non-static data members?

Question

I'm sick of writing constructors manually. How can I automate this?

struct MyFunctor {
public:
  MyFunctor(/* repeat what I wrote again!*/)
  :/* repeat what I wrote again! */
  { }

  bool operator()() { return true; }

private:
  Controller *m_controller;
  String m_action;
  bool m_allowRejection;
  /* ... */
};

You mean you want to accept the types of members and to a direct initialization? — GManNickG, Mar 30 '11 at 06:28
Do you want the argument list to have `Controller* a_controller, String a_action, bool a_allowRejection`? Would a fugly fugly macro work? — James McNellis, Mar 30 '11 at 06:28
you can use some code refactoring tool for c++ to speed up writing your code, [good post 1](http://stackoverflow.com/questions/16167/good-refactoring-support-for-c) [good post 2](http://stackoverflow.com/questions/1388469/is-there-a-working-c-refactoring-tool), also [search by google](http://goo.gl/4IGUb). but i not confident that they generate constructors — Taras Mazepa, Mar 30 '11 at 06:43
You may want to switch the private and public parts. It's really confusing for the reader to start with "repeat what I wrote again!". I was like "WTF is he talking about?". — fredoverflow, Mar 30 '11 at 06:47
How would we automagically know if we should pass parameters by value, const reference, or as a pointer? — Bo Persson, Mar 30 '11 at 07:48
@Bo: Simply pass everything by reference to const, that should cover the majority of cases. — fredoverflow, Mar 30 '11 at 07:58
@FredOverflow - But for the m_controller, would I get a reference to a Controller or a reference to a pointer? And I certainly would like an rvalue reference for the String. I'm sure Johannes doesn't want to repeat all parameters if only one should be non-default. :-) — Bo Persson, Mar 30 '11 at 08:42
@Bo: A reference to a pointer. I would certainly *not* like an rvalue reference for the string, because then I could not pass in lvalues anymore. For efficiently movable types, it would probably be best to pass them by value and then move them from the parameters into the members. — fredoverflow, Mar 30 '11 at 08:56

score 3 · Answer 1 · answered Mar 30 '11 at 06:52

You could give up data hiding and use good-old struct initialization from C:

struct MyFunctor
{
    Controller *m_controller;
    String m_action;
    bool m_allowRejection;

    bool operator()() const
    {
        return true;
    }
};

MyFunctor fun = {&some_controller, "hello world", false};

In C++0x, you can even create objects on-the-fly thanks to uniform initialization:

some_function( MyFunctor {&some_controller, "hello world", false} );

...or you could switch to Scala and use primary constructors ;)

This doesn't work when the class inherits another class (the class becomes a non-aggregate :() — Johannes Schaub - litb, Mar 30 '11 at 15:31

score 1 · Answer 2 · answered Mar 30 '11 at 06:47

A macro like this could be of use, though it's arguably ugly:

#include <boost/preprocessor.hpp>

#define AUTO_CONSTRUCTOR_DETAIL_PARAM(r, data, member) \
        BOOST_TYPEOF(member) member

#define AUTO_CONSTRUCTOR_DETAIL_INIT(r, data, member) \
        member(member)

#define AUTO_CONSTRUCTOR_DETAIL(className, mems) \
        className(BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM( \
                    AUTO_CONSTRUCTOR_DETAIL_PARAM, BOOST_PP_EMPTY, members))) : \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM( \
            AUTO_CONSTRUCTOR_DETAIL_INIT, BOOST_PP_EMPTY, member)) \
        {}  

#define AUTO_CONSTRUCTOR(className, members) \
        AUTO_CONSTRUCTOR_DETAIL(className, members)

Use as:

struct MyFunctor {
public:
  AUTO_CONSTRUCTOR(MyFunctor, (m_controller)(m_action)(m_allowRejection)) 

  bool operator()() { return true; }

private:
  Controller *m_controller;
  String m_action;
  bool m_allowRejection;
  /* ... */
};

Untested, of course.

I don't think `BOOST_TYPEOF(member)` is valid. It's not a valid expression for nonstatic data members :( — Johannes Schaub - litb, Mar 30 '11 at 07:41
@Johannes: Do you think `BOOST_TYPEOF(((data*)0)->member)` would work, then? (Where `data` is `className`.) — GManNickG, Mar 30 '11 at 07:56

score 0 · Answer 3 · answered Mar 30 '11 at 08:09

Uhm... GMan's answer got me into thinking on interleaved macros:

#define FOR_EACH_FIELD( macro ) \
   macro( Controller*, m_controller ) \
   macro( String, m_action ) \
   macro( bool, m_allowRejection )

And then abuse that macro with other macros that add bits and pieces for formatting... I was going to try it, but it becomes a mess quite easily... At any rate my guess is that it is not worth the effort. The final use would be something like:

struct MyFunctor {
#define FOR_EACH_FIELD( macro ) // as above
   CREATE_CONSTRUCTOR( MyFunctor, FOR_EACH_FIELD ) // this macro will call others.
   bool operator()() {}
private:
   CREATE_FIELDS( FOR_EACH_FIELD );
#undef FOR_EACH_FIELD
};

score 0 · Answer 4 · edited May 23 '17 at 12:00

0

If you only need value-initialization you could use a template as described here - neat and you don't repeat yourself.

edited May 23 '17 at 12:00

Community

1
1

answered Mar 30 '11 at 08:42

sharptooth

167,383
100
513
979

score 0 · Answer 5 · answered Mar 30 '11 at 09:17

I'm not sure there is an easy answer: at some point, you have to tell the compiler what the initialization values are. For certain frequent patterns, however, you could probably write a simple code generator: you'd provide a file in entry with a three column list: name, type and default initializer, and the compiler would generate the default constructor, the initialing constructor and the data. (It would be simple to extend to allow additional functions.)

score 0 · Answer 6 · answered Mar 30 '11 at 13:48

If you were using this purely as a storage type of class, you could use Boost::tuple, which automatically generates such a ctor, so your class would look something like:

tuple<Controller, String, bool> MyFunctor;

The problem with this is that it doesn't provide any way for you to include your operator(). Unfortunately, since ctors aren't inherited, you could not accomplish anything by trying to create a functor_base using boost::tuple, then deriving a class that added your operator().

The obvious alternative would be to rewrite tuple allow you to specify the code for various member functions. I'm not sure how to do that right off though -- it would take some careful thought (at best).

Automatically generate constructors based on non-static data members?

6 Answers6