Are variadic templates a potential code bloat?

The short answer is: the "you only pay for what you use" principle still applies exactly as before The longer answer can be seen by comparing the generated code for two hypothetical implementations e. G include template void func1(T& v) { v = -10; } template void func1(T1& v1, T2& v2) { func1(v1); func1(v2); } // More unused overloads.... template void func1(T1& v1, T2& v2, T3& v3) { func1(v1); func1(v2); func1(v3); } int main() { double d; int i; func1(d); func1(i); std::cout The compiler basically is writing all of the overloads your program requires on the fly and then optimizing as before The following non template code also produces almost identical output: include #include int main() { double d; int i; d= -10; i=-10; std::cout.

The short answer is: the "you only pay for what you use" principle still applies exactly as before. The longer answer can be seen by comparing the generated code for two hypothetical implementations e.g. #include template void func1(T& v) { v = -10; } template void func1(T1& v1, T2& v2) { func1(v1); func1(v2); } // More unused overloads.... template void func1(T1& v1, T2& v2, T3& v3) { func1(v1); func1(v2); func1(v3); } int main() { double d; int i; func1(d); func1(i); std::cout In this "traditional" C++03 templated code my version of g++ inlines (in the compiler, not keyword sense) the whole lot and there's no obvious hint that the initializations are done via reference in a template function, several times, in different ways. Compared with the equivalent variadic approach: #include #include void func1() { // end recursion } template void func1(T& v, Args&... args) { v = -10; func1(args...); } int main() { double d; int i; func1(d); func1(i); std::cout The following non template code also produces almost identical output: #include #include int main() { double d; int i; d= -10; i=-10; std::cout If it's not then the output will be more substantial, but so would the output be if you'd avoided templates entirely.

Where this gets interesting (in my view) however is this: all of my statements were qualified with something like "with an decent modern compiler". If you're writing variadic templates you can almost be certain that what you're using to compile is a decent modern compiler.No clunky old relic compilers support variadic templates.

It could certainly be a problem. One thing that could help is to factor out the common parts: const char *process(const char *s) { while (*s) { if (*s == '%' && *(++s)! = '%') { ++s; return s; } std::cout inline const char *process(const char *s,T value) { s = process(s); std::cout inline void printf(const char *s, T value, Args... args) { printf(process(s,value),args...); }.

I cant really gove you an answer,but what I can give you is a way to a solution, that is you have to find the anglde that you relate to or peaks your interest. A good paper is one that people get drawn into because it reaches them ln some way.As for me WW11 to me, I think of the holocaust and the effect it had on the survivors, their families and those who stood by and did nothing until it was too late.