c++14

I'm trying to write a Bind metaprogramming template helper metafunction that binds a template parameter to something. I have a working implementation for simple template metafunctions: template<typename T0, typename T1> struct MakePair { using type = std::pair<T0, T1>; }; template<template<typename...> class TF, typename... Ts> struct Bind { template<typename... TArgs> using type = TF<Ts..., TArgs...>; }; using PairWithInt = typename Bind<MakePair, int>::type; static_assert(std::is_same<PairWithInt<float>, MakePair<int, float>>{}, ""); But what if MakePair 's template arguments were template

I was having fun with attempts to pass function template as template template argument. Of course C++ doesn't allow passing function templates this way. But I came up with simple hax: #include <iostream> #define PASS_TEMPLATE(name) [](auto&... args){return name(args...);} template <typename T, typename S> void function_template(T t, S s) {std::cout << t << ' ' << s << std::endl;} template <typename Hax, typename T, typename S> auto test(Hax hax, T t, S s) { return hax(t, s); } int main() { test(PASS_TEMPLATE(function_template), 1, 1.5); } Demo The question is: Is this viable approach? (Is it

I'm really happy to have discovered for_each_arg(...) , which makes dealing with argument packs much easier. template<class F, class...Ts> F for_each_arg(F f, Ts&&...a) { return (void)initializer_list<int>{(ref(f)((Ts&&)a),0)...}, f; } I'm, however, confused on its correct usage. There are many arguments that need to be perfectly forwarded, but am I performing any unnecessary forwarding? Reading the code becomes harder with excessive fowarding. struct UselessContainer { // Expects a perfectly-forwarded item to emplace template<typename T> void add(T&&) { } }; // Creates an `UselessContainer`

In another question a user made a comment that returning a const std::string loses move construction efficiency and is slower. Is it really true that assigning a string of return of this method: const std::string toJson(const std::string &someText); const std::string jsonString = toJson(someText); ... is really slower than the non-const version: std::string toJson(const std::string &str); std::string jsonString = toJson(someText); And what is the meaning of move-construction efficiency in this context? I've never heard of that limitation before and do not remember having seen that in the

Given a (reduced) implementation of the detection idiom namespace type_traits { template<typename... Ts> using void_t = void; namespace detail { template<typename, template<typename...> class, typename...> struct is_detected : std::false_type {}; template<template<class...> class Operation, typename... Arguments> struct is_detected<void_t<Operation<Arguments...>>, Operation, Arguments...> : std::true_type {}; } template<template<class...> class Operation, typename... Arguments> using is_detected = detail::is_detected<void_t<>, Operation, Arguments...>; template<template<class...> class

I am writing some code to read bitmap files. Here is the struct I am using to read the bitmap header. See also: https://msdn.microsoft.com/en-us/library/windows/desktop/dd183374(v=vs.85).aspx struct BITMAPFILEHEADER { WORD bfType; // 2 DWORD bfSize; // 6 WORD bfReserved1; // 8 WORD bfReserved2; // 10 DWORD bfOffBits; // 14 }; // should add to 14 bytes If I put the following code in my main function: std::cout << "BITMAPFILEHEADER: " << sizeof(BITMAPFILEHEADER) << std::endl; the program prints: BITMAPFILEHEADER: 16 It appears to be re-aligning the data in the struct on 4-byte boundaries,

I have 2 or more classes which inherit from a single parent. They all have overloaded handle methods, but each class has different parameters for their handle methods. class CommandHandler {}; class FooCommandHandler : public CommandHandler { public: string handle(const FooCommand& c) { return c.getStringSomehow(); } }; class BarCommandHandler : public CommandHandler { public: string handle(const BarCommand& c) { return c.getStringSomeOtherWay(); } string handle(const OtherBarCommand& c) { return c.youGetThePicture(); } }; FooCommandHandler fooHandler; BarCommandHandler barHandler; I want a