Let’s go over the conditions as they appear: If const T isn’t const (const doesn’t really apply to function types since functions aren’t objects), and T isn’t a reference (const doesn’t apply to references either for the same reason), it’s a function type. int (or any other non-function-non-reference type) wouldn’t fit in because is_const<const int>::value … Read more
One of the places where a pack expansion can occur is inside a braced-init-list. You can take advantage of this by putting the expansion inside the initializer list of a dummy array: template<typename… Args> static void foo2(Args &&… args) { int dummy[] = { 0, ( (void) bar(std::forward<Args>(args)), 0) … }; } To explain the … Read more
If DEBUG is enabled, there’s a template tag called {% debug %}
Before going into what a mix-in is, it’s useful to describe the problems it’s trying to solve. Say you have a bunch of ideas or concepts you are trying to model. They may be related in some way but they are orthogonal for the most part — meaning they can stand by themselves independently of … Read more
With a C++11 compliant compiler, you can do something like this: template<class Derived> class MyClass { MyClass() { // Compile-time sanity check static_assert(std::is_base_of<BaseClass, Derived>::value, “Derived not derived from BaseClass”); // Do other construction related stuff… … } } I’ve tested this out using the gcc 4.8.1 compiler inside a CYGWIN environment – so it should … Read more
3 simple rules for you to get it right: No syntax issue can affect performance. Data manipulation does. Speak of performance only backed with results of profiling. Premature optimization is the root of all evil Performance issues are quite hard to understand. It is advised for the newbies not to take it into account. Because … Read more
There are two ways. The first one is by specifying the interface statically for the structure of types: template <class Derived> struct base { void foo() { static_cast<Derived *>(this)->foo(); }; }; struct my_type : base<my_type> { void foo(); // required to compile. }; struct your_type : base<your_type> { void foo(); // required to compile. }; … Read more
Simple Lambda So simple, so useful – a little lambda: Shortcut: x Available: C# where expression is allowed. x => x.$END$ Macros: none.
It seems for the moment string concatenation is faster: http://jsperf.com/es6-string-literals-vs-string-concatenation ES6 with variable 19,992,512 ±5.21% 78% slower String concatenation with variable 89,791,408 ±2.15% fastest ES6 with function 461,358 ±3.12% 99% slower String concatenation with function 503,255 ±1.77% 99% slower I tested was run on Chrome 43.0.2334.0 canary (64-bit), which is using V8 4.3.31, with the … Read more
Alternatively you could load in grunt plugins to help this: grunt-shell example: shell: { make_directory: { command: ‘mkdir test’ } } or grunt-exec example: exec: { remove_logs: { command: ‘rm -f *.log’ }, list_files: { command: ‘ls -l **’, stdout: true }, echo_grunt_version: { command: function(grunt) { return ‘echo ‘ + grunt.version; }, stdout: true … Read more