c++14

Are C++ standard library implementations allowed to add public (and protected) members to standard types' interfaces? N3797 17.6.5.5 [member.functions]/2 says: An implementation may declare additional non-virtual member function signatures within a class: — by adding arguments with default values to a member function signature; [ Note : An implementation may not add arguments with default values to virtual, global, or non-member functions. — end note ] — by replacing a member function signature with default values by two or more member function signatures with equivalent behavior; and — by

I was recently playing with CRTP when I came across something that surprised me when used with c++1y functions whose type is deduced. The following code works: template<typename Derived> struct Base { auto foo() { return static_cast<Derived*>(this)->foo_impl(); } }; struct Derived: public Base<Derived> { auto foo_impl() -> int { return 0; } }; int main() { Derived b; int i = b.foo(); (void)i; } I assumed that the return type from Base<Derived>::foo was a decltype of the expression returned, but if I modify the functio foo like this: auto foo() -> decltype(static_cast<Derived*>(this)->foo_impl(

This is a follow-up question on this one: Lambda-Over-Lambda in C++14 , where the answers explain the code. It is about a lambda that creates another lambda which when called, calls the passed lambda and passes the return value to the original lambda, thus returning a new instance of the second lambda. The example shows how this way lambdas can be chained. Copy from the original question: #include <cstdio> auto terminal = [](auto term) // <---------+ { // | return [=] (auto func) // | ??? { // | return terminal(func(term)); // >---------+ }; }; auto main() -> int { auto hello =[](auto s){

2 Questions: Is the following code well formed with defined behaviour? Is there any possible c++ implementation in which it could assert? Code (c++11 and higher): #include <cassert> #include <utility> #include <ciso646> template<class T> auto to_address(T* p) { return reinterpret_cast<unsigned char const*>(p); } /// Test whether part is a sub-object of object template<class Object, class Part> bool is_within_object(Object& object, Part& part) { auto first = to_address(std::addressof(object)), last = first + sizeof(Object); auto p = to_address(std::addressof(part)); return (first <= p) and (p <