Duplicating source code

[camsr]

What are some alternatives to writing duplicate code in the source? My specific example is plugin state initialization/reset, where I find the same block of code in 3 different member functions of my plugin.
There's always the venerable C macro
Maybe an IDE plugin that pushes changes in one block of text to different areas?
C++ templates maybe?
Scripts?

[Miles1981]

The same block three times? So this means that you probably need this state to do something similar, so probably a class that initializes the content in the constructor and 3 different methods that may share similar code paths?

[Squidsneeze]

Hi, why don't you just put the duplicate code into a function and call it? I think this could be a default constructor, too.

[camsr]

Guaranteed inlining...
A source level solution is what's best.

[camsr]

Hi, why don't you just put the duplicate code into a function and call it? I think this could be a default constructor, too.

It generates unnecessary instructions/indirection.

[camsr]

Is it certain that this kind of call will inline?

this->st_init();

[Squidsneeze]

You could use the "__forceinline" keyword, then it should (don't know if it's a MSVS only keword). Else a bit unconventional, but you could put the code into a file which gets included at the needed positions.

[camsr]

Yeah, that's the guaranteed way of doing it! And it's very inflexible, imagine renaming a hundred constants...

[MadBrain]

You could use the "__forceinline" keyword, then it should (don't know if it's a MSVS only keword). Else a bit unconventional, but you could put the code into a file which gets included at the needed positions.

Yes, __forceinline is MSVC only but GCC has the equivalent inline __attribute__((always_inline)) so it's a matter of setting up a #define. Actually I'm not sure why they haven't harmonized those between MSVC and GCC/LLVM, like they did with other stuff like #pragma pack.

[stratum]

Actually I'm not sure why they haven't harmonized those between MSVC and GCC/LLVM, like they did with other stuff like #pragma pack.

Not the worst gcc/msvc mismatch. How about this one : http://stackoverflow.com/questions/1537 ... ute-packed Was that really harmonized and I have missed it?

[camsr]

I guess what I am really looking for is a way to modify source code by some pre-defined pattern. Like adding new parameters for instance, instead of moping through the source copying/pasting and editing, just be able to define everything required in one area and have it automatically propagated via some scripted pattern. It's 2017, people are even using voice to code

[stratum]

We are still in the stone age where considerable time is spent by deleting "const std::string&" phrases form code that you have copied from another file

[aciddose]

A function is the proper solution. In combination with template meta-programming.

A template functor can be used to ensure inlining along with some compiler-specific defines. Generally these won't be needed though.

The biggest issue is that you're using constructors where indirection or function-call overhead could actually make up any significant issue! This is a very, very, very, very, very, very bad sign. I can't type very enough times to express how very bad it is.

If you're writing optimized code that executes in tight loops you shouldn't be anywhere near using the heap or calling constructors.

In every other case however function-call overhead is entirely insignificant.

[camsr]

aciddose, I think I agree with you. It probably is insignificant, the only tradeoff is having the same set of data in 3 separate areas.

[Miles1981]

Forced inline through a keyword is a bad idea. The compiler has heuritics for inlining, and you should trust them.

If your initialization is more than a few variables, even if your function is not inlined, it won't matter much. A few registers on the stack, one additional unconditional predictable jump? That's nothing compared to even one branch test.