c++14

What's a succinct way of ranging through N variables, of any type each, to perform an operation? Let's say I have variables a , b , c , d , e and want to go through all of them performing some operation. Use Boost.Hana and generic lambdas: #include <tuple> #include <iostream> #include <boost/hana.hpp> #include <boost/hana/ext/std/tuple.hpp> struct A {}; struct B {}; struct C {}; struct D {}; struct E {}; int main() { using namespace std; using boost::hana::for_each; A a; B b; C c; D d; E e; for_each(tie(a, b, c, d, e), [](auto &x) { cout << typeid(x).name() << endl; }); } http://coliru.stacked

This question is about the code (at namespace scope): std::vector<int> v1; std::vector<int> v2(4); In section 3.6.2 of C++14 (N4140) there is defined a term Constant initialization : Constant initialization is performed: [omitted - about reference initialization] if an object with static or thread storage duration is initialized by a constructor call, and if the initialization full-expression is a constant initializer for the object; if an object with static or thread storage duration is not initialized by a constructor call and if either the object is value-initialized or every full

This question already has answers here : How does `void_t` work (2 answers) Closed last year . I have a program that is as follows. There is a base template struct X and a partial specialisation with SFINAE. template <typename T, typename U = void> struct X{ X() { std::cout << "in 1" << std::endl; }; }; template <typename T> struct X< T, std::enable_if_t<std::is_integral_v<T>> > { X() { std::cout << "in 2" << std::endl; }; }; int main() { X<int> x; } When running the program in 2 is printed. Why is it that the second specialization is chosen over the first since both of them effectively

How to self-document a type-alias that is used in another certain library? In the below example, class User defines an alias User::type that is supposed to be referred only in class Library via T::type . Here is the diagram :- Library.h Library<T> expected only T that defines a certain alias (e.g. T::type in this example). #include <iostream> class Base{}; //dummy for the sake of example template<class T>class Library{ Base* t=nullptr; public: typename T::type getValue(){return static_cast<typename T::type>(t);} //some complex function, e.g. T::aType::doSomething() }; In real cases, Library<T>

I am attempting to build Qt 5.4.1 pulled from git with the -std=c++14 flag for gcc4.9. But I am not sure about how to properly pass the flag into the build process. I have read that adding CONFIG += c++14 to a qt project file should work since Qt5.4, so I have added it into the qt.pro located in the top folder. But Qt is still compiled with -std=c++0x (c++11). If you using g++ or clang++ to build the Qt 5 , then go to qt5/qtbase/mkspecs/common/g++-base.conf or qt5/qtbase/mkspecs/common/clang.conf respectively and simply change the right hand side of QMAKE_CXXFLAGS_CXX11 = -std=c++11 assignment

Suppose I have a following variadic template structure: template <class... T> struct Example {}; Now I want to define a template function: template<class... S> ??? f() { return Example<???> } where the specialization of Example<> is depend on the template parameter S of f . To be more concrete (and simple), now I just want to return Example<int, ...,int> , where the number of int is the size of the parameter pack S . How can it be done in modern C++, i.e. C++11/14/17? More generally, is there a way to at compile time define a function on template parameters? When doing template meta

This question already has an answer here: Overloaded lambdas in C++ and differences between clang and gcc 2 answers Time for another round of clang vs gcc . Live example on godbolt.org . Test 0 : overloaded callable object struct Trad { auto operator()(int) { return 1; } auto operator()(float) { return 2; } auto operator()(double) { return 3; } }; int main() { assert(Trad{}(1) == 1); assert(Trad{}(1.f) == 2); assert(Trad{}(1.0) == 3); } g++ 5.2 compiles and run. clang++ 3.5 (and later versions) compiles and run. Test 1 : overloaded callable object, generated via lambda inheritance template