Try this: #include <type_traits> template <typename T, template <typename> class Tmpl> // #1 see note struct is_derived { typedef char yes[1]; typedef char no[2]; static no & test(…); template <typename U> static yes & test(Tmpl<U> const &); static bool const value = sizeof(test(std::declval<T>())) == sizeof(yes); }; Usage: #include <iostream> template<class T> struct X {}; struct … Read more
It looks like we can find a rationale for this change in defect report 348, which says: Specifically, standard says in 5.3.5 [expr.delete] paragraph 2: …if the value of the operand of delete is the null pointer the operation has no effect. Standard doesn’t specify term “has no effect”. It is not clear from this … Read more
tl;dr: The sequence of the modifications and reads performed in (i+=10)+=10 is well defined in both C++98 and C++11, however in C++98 this is not sufficient to make the behavior defined. In C++98 multiple modifications to the same object without an intervening sequence-point results in undefined behavior, even when the order of those modifications is … Read more
Core Language Accessing an enumerator using ::: template<int> struct int_ { }; template<typename T> bool isCpp0xImpl(int_<T::X>*) { return true; } template<typename T> bool isCpp0xImpl(…) { return false; } enum A { X }; bool isCpp0x() { return isCpp0xImpl<A>(0); } You can also abuse the new keywords struct a { }; struct b { a a1, … Read more
The classic example of cyclic references is where you have two classes A and B where A has a reference to B which has a reference to A: #include <memory> #include <iostream> struct B; struct A { std::shared_ptr<B> b; ~A() { std::cout << “~A()\n”; } }; struct B { std::shared_ptr<A> a; ~B() { std::cout << … Read more
The answer is a definite yes. On the plus side there is: Code that previously implicitly copied objects will now implicitly move them when possible. On the negative side, several examples are listed in the appendix C of the standard. Even though there are many more negative ones than positive, each one of them is … Read more
The answer given by Alexey Malistov can be used on MSVC with a minor modification: namespace { template<class T, int discriminator> struct is_complete { static T & getT(); static char (& pass(T))[2]; static char pass(…); static const bool value = sizeof(pass(getT()))==2; }; } #define IS_COMPLETE(X) is_complete<X,__COUNTER__>::value Unfortunately, the __COUNTER__ predefined macro is not part of … Read more
This question (about the closely related digraphs) has the answer. It boils down to the fact that the ISO 646 character set doesn’t have all the characters of the C syntax, so there are some systems with keyboards and displays that can’t deal with the characters (though I imagine that these are quite rare nowadays). … Read more
Your colleague is correct for C++03: [C++03: 9.2/12]: Nonstatic data members of a (non-union) class declared without an intervening access-specifier are allocated so that later members have higher addresses within a class object. The order of allocation of nonstatic data members separated by an access-specifier is unspecified (11.1). [..] But you are correct for C++11: … Read more
In C++11, auto has new meaning: it allows you to automatically deduce the type of a variable. Why is that ever useful? Let’s consider a basic example: std::list<int> a; // fill in a for (auto it = a.begin(); it != a.end(); ++it) { // Do stuff here } The auto there creates an iterator of … Read more