-----Original Message----- From: boost-bounces@lists.boost.org [mailto:boost-bounces@lists.boost.org] On Behalf Of Paul Mensonides
The "ctor_template.hpp" header (as it currently exists) is such a function, but its initial call (the one that starts the iteration) is done by the client, not the file-iteration mechanism. You have to write that file as if it is a function--not a header. But you should also provide a normal header that defines the interface to the function (i.e. BOOST_FORWARDER_CTOR_TEMPLATE()) and includes the files needed by the function.
I see that you updated your library! A couple of quick notes... 1) Because the macro names are uppercased (annoying, but necessary), the comments at the top of the "detail/ctor_template.hpp" file need to be updated. 2) The #error directive on line 18 has an unmatched double-quote. Any standard-compliant preprocessor will yield a tokenization error, as the contents of #error directives are still tokenized (just like everything else except comments). Simple fix: add a closing double-quote. Regarding what the generated code is doing (as opposed to what the generator code is doing), the major problem with forwarding without language support is that it is a combinatorial problem--rather than linear. I.e. you really need various combinations of const and-or volatile and non-cv-qualified references in generic libraries. E.g. to support exactly two parameters, you need 16 functions. If you ignore volatile (which you could get away with in 99% of situations), you can reduce the above to just 4 functions. Increasing the number of parameters exponentially increases the number of functions needed. E.g. with three parameters, you need 8 functions. IOW, you need Q^N functions to support N parameters with Q possible qualifiers. This, in turn is additive when you support 0 to N parameters: 1 + Q + Q^2 + Q^(N-2) + Q^(N-1) + Q^N. In other words a summation of Q^N with N ranging from 0 to your maximum arity. So you need, for example, 31 functions total to handle up to 4 parameters where each parameter can be const or non-const qualified. With volatile, you need 341 functions total to handle up to *just* 4 parameters. At up to 5 parameters, the number of functions is well over a thousand. At 6, over 5000. It breaks the million function mark at 10 parameters. At up to 10 parameters, but ignoring volatile, it is only a "measily" 2047 functions. In any case, it is still reasonable up to 5 parameters if you're ignoring volatile. I know that Dave implemented this kind of forwarding for an operator new workalike that returned a smart pointer. (With perfect forwarding, you can design a reference-counted smart pointer so that it doesn't require a double allocation.) Regards, Paul Mensonides