standards

I am stuck in deciding between choosing Google App Engine Standard Vs. Flexible environment for a real world production. I want to use Java definitely. Need to use Firebase(latest version) for Authentication and Push notification; I'm not sure whether new Firebase is compatible with standard or flexible. per the caution note in the following link, my impression is that recent Firebase is compatible is with Flexible Environment only. https://cloud.google.com/solutions/mobile/firebase-app-engine-android-studio All things being equal any standard environment app can also run in a flexible

There is a study group on ranges in the C++ committee: but I have not followed the history of this study group and I am not sure of what kind of delivery is expected for C++1z (furthermore I do not use boost.range so I do not have a clear view of existing practices). Will we have: ranges as a pair of first/last iterators? union and other set operations on ranges(for example [v.begin()+5, v.begin()+7[ U [v.begin()+10, v.begin()+15[ U [v.begin()+21, v.begin()+42[ ), namely: union, intersection, disjoint union, complement? iterator filters (in order to execute a for_each where a condition is

A commonly-used macro in the linux kernel (and other places) is container_of , which is (basically) defined as follows: #define container_of(ptr, type, member) (((type) *)((char *)(ptr) - offsetof((type), (member)))) Which basically allows recovery of a "parent" structure given a pointer to one of its members: struct foo { char ch; int bar; }; ... struct foo f = ... int *ptr = &f.bar; // 'ptr' points to the 'bar' member of 'struct foo' inside 'f' struct foo *g = container_of(ptr, struct foo, bar); // now, 'g' should point to 'f', i.e. 'g == &f' However, it's not entirely clear whether the

Why can't I have int a; in 2 C files. I intend to combine both to make executable. I know from experience that I can't, but I want to find where the standard C99 says this and seal my understanding. I am reading ISO C99 standard from http://www.open-std.org/jtc1/sc22/wg...docs/n1256.pdf . It says on page 42: 6.2.2 Linkages of identifiers 1 An identifier declared in different scopes or in the same scope more than once can be made to refer to the same object or function by a process called linkage.There are three kinds of linkage: external, internal, and none. 2 In the set of translation units and

The C++ standard states that returning reference to a local variable (on the stack) is undefined behaviour, so why do many (if not all) of the current compilers only give a warning for doing so? struct A{ }; A& foo() { A a; return a; //gcc and VS2008 both give this a warning, but not a compiler error } Would it not be better if compilers give a error instead of warning for this code? Are there any great advantages to allowing this code to compile with just a warning? Please note that this is not about a const reference which could lengthen the lifetime of the temporary to the lifetime of the