standards

I got this basic doubt. The STL header doesn't have .h extension. #include <vector> #include <map> Is there is any specific reason behind this? Anybody knows history behind this, please share. EDIT : @GMan found Michael Burr's answer which addresses this question. The #include directive doesn't discriminate file types (it's just a glorified copy-paste operation) - no automatic adding of .h is happening. C++ standard header files are provided without the .h extension Sometimes backward compatibility header files are provided by the vendor with the same name with the .h extension added It all

Code: #include <memory> using namespace std; struct T {}; T* foo() { return new T; } T const* bar() { return foo(); } int main() { unique_ptr< T const > p1( bar() ); // OK unique_ptr< T const [] > a1( bar() ); // OK unique_ptr< T const > p2( foo() ); // OK unique_ptr< T const [] > a2( foo() ); // ? this is line #15 } Example errors with Visual C++ 10.0 and MinGW g++ 4.4.1: [d:\dev\test] > cl foo.cpp foo.cpp foo.cpp(15) : error C2248: 'std::unique_ptr<_Ty>::unique_ptr' : cannot access private member declared in class 'std::unique_ptr<_Ty>' with [ _Ty=const T [] ] C:\Program Files (x86)

std::function provides a constructor from an rvalue ref. What happens to the moved function object by standard? Will it be empty so that calling it again has no effects? Under 20.8.11.2.1p6, function(function &&f) leaves f in a valid state with an unspecified value . The empty state is a valid state, so you should expect that the moved from function object can be empty. Because function performs type erasure, and function objects can be arbitrarily expensive, the optimisation to leave the moved from object empty makes sense: std::function<void()> g{std::bind{f, std::array<int, 1000>{}}}; std:

With printf() , I can use %hhu for unsigned char , %hi for a short int , %zu for a size_t , %tx for a ptrdiff_t , etc. What conversion format specifier do I use for a _Bool ? Does one exist in the standard? Or do I have to cast it like this: _Bool foo = 1; printf("foo: %i\n", (int)foo); There is no specific conversion length modifier for _Bool type. _Bool is an unsigned integer type large enough to store the values 0 and 1 . You can print a _Bool this way: _Bool b = 1; printf("%d\n", b); Because of the integer promotions rules, _Bool is guaranteed to promote to int . Until C99, bool was not

As it currently stands, this question is not a good fit for our Q&A format. We expect answers to be supported by facts, references, or expertise, but this question will likely solicit debate, arguments, polling, or extended discussion. If you feel that this question can be improved and possibly reopened, visit the help center for guidance. Closed 7 years ago . I was wondering if, and to what degree, does Microsoft's Visual C++ compiler conform to the current C (C90/C99) and C++ (ISO/IEC 14882:2003) standards. Unfortunately I'm only able to find partial information on the subject, I may be

I was reading these two paragraphs of the FDIS (12.2p{4,5}): There are two contexts in which temporaries are destroyed at a different point than the end of the full-expression. The first context is when a default constructor is called to initialize an element of an array. If the constructor has one or more default arguments, the destruction of every temporary created in a default argument is sequenced before the construction of the next array element, if any. and The second context is when a reference is bound to a temporary. The temporary to which the reference is bound or the temporary that