c++14

Consider the specification of the range-based for loop's begin-expr and end-expr (N4140 [stmt.ranged]/p1). Given a range __range of type _RangeT , begin-expr and end-expr are determined as follows: if _RangeT is an array type, begin-expr and end-expr are __range and __range + __bound , respectively, where __bound is the array bound. If _RangeT is an array of unknown size or an array of incomplete type, the program is ill-formed; if _RangeT is a class type, the unqualified-id s begin and end are looked up in the scope of class _RangeT as if by class member access lookup (3.4.5), and if either

Recently I've discovered that sometimes being able to turn rvalues temporarily into lvalues can be useful for me. I've been using the following tool: #include <type_traits> template <typename T> inline constexpr std::remove_reference_t<T> &lvalue(T &&r) noexcept { return static_cast<std::remove_reference_t<T> &>(r); } It's useful when you have to use functions that require lvalues as arguments, but you don't have any interest in what those particular values get changed into. For when you are interested in other output vectors that are not related to the given specific argument. For example,

I'm trying to implement a "property" system to convert C++ instances into JSON and vice versa. I took a part of the code from Guillaume Racicot's answer in this question ( C++ JSON Serialization ) and simplified it. Here is how I proceed. I have a Property class: template <typename Class, typename T> struct Property { constexpr Property(T Class::* member, const char* name) : m_member(member), m_name(name) {} T Class::* m_member; const char* m_name; }; m_member points to a specific member of Class Let's say I want to define properties for a User class, I would like to be able to proceed like

std::make_unique() (and similar functions) have a little problem : #include <cstdio> #include <memory> using namespace std; struct S { S() { printf("ctor\n"); } ~S() { printf("dtor\n"); } S(S const&) { printf("cctor\n"); } S(S&&) { printf("mctor\n"); } }; S foo() { return S(); } int main() { { printf("--------------- case 1 ---------------\n"); unique_ptr<S> s1 = make_unique<S>( foo() ); } { printf("--------------- case 2 ---------------\n"); unique_ptr<S> s2 { new S( foo() ) }; } } Output: --------------- case 1 --------------- ctor mctor dtor dtor --------------- case 2 --------------- ctor

While clang compiles the following line, g++ 6.1 complains about the digit separator (see live example on Coliru ): auto time = 01'23s; Which compiler, if any, is correct according to the C++14 standard (N3796)? Otherwise, is allowing digit separators (§2.14.2) just an implementation detail in the user-defined literals (§2.14.8) of the <chrono> library (§20.12.5.8)? IMHO it should be not, since these literals are defined on unsigned long long parameters. I remember Howard Hinnant using 10'000s as an example during his CppCon 2016 talk "A <chrono> tutorial" (at about 42 minutes in his talk).

Given a possibly varargs function type with possibly a cv-qualifier-seq and possibly a ref-qualifier , is it possible to write a type trait that strips all the qualifiers without writing 4 * 3 * 2 = 24 partial specializations? template<class T> struct strip_function_qualifiers; template<class R, class... Args> struct strip_function_qualifiers<R(Args...)> { using type = R(Args...); }; template<class R, class... Args> struct strip_function_qualifiers<R(Args..., ...)> { using type = R(Args..., ...); }; template<class R, class... Args> struct strip_function_qualifiers<R(Args...) const> { using

I have seen anonymous classes in C++ code on Quora. It's successfully compiled and run. Code here: #include <iostream> auto func() { class // no name { public: int val; } a; a.val = 5; return a; } int main() { std::cout << func().val << std::endl; return 0; } So, Is it valid in C++? Also, I am curious to know, Is it possible to use anonymous classes in C++? In C++, an anonymous union is a union of this form: union { ... } ; It defines an unnamed object of an unnamed type. Its members are injected in the surrounding scope, so one can refer to them without using an <object>. prefix that

I would like to know if there is a nice way to iterate over at most N elements in a container using the range based for loop and/or algorithms from the standard library (that's the whole point, I know I can just use the "old" for loop with a condition). Basically, I'm looking for something that corresponds to this Python code: for i in arr[:N]: print(i) PiotrNycz As I personally would use either this or this answer (+1 for both), just for increasing your knowledge - there are boost adapters you can use. For your case - the sliced seems the most appropriate: #include <boost/range/adaptor/sliced