unspecified-behavior

The C++ standard (quoting from draft n3242) says the following about subobjects [intro.object]: Unless an object is a bit-field or a base class subobject of zero size, the address of that object is the address of the first byte it occupies. Two distinct objects that are neither bit-fields nor base class subobjects of zero size shall have distinct addresses. Now, given the following snippet: struct empty { }; struct member: empty { }; struct derived: empty { member m; }; int main(void) { printf("%d", sizeof(derived)); return 0; } gcc I believe prints out 2 , and Visual C++ 2010 prints out 1 . I

Suppose I have the following: #include <memory> struct A { int x; }; class B { B(int x, std::unique_ptr<A> a); }; class C : public B { C(std::unique_ptr<A> a) : B(a->x, std::move(a)) {} }; If I understand the C++ rules about "unspecified order of function parameters" correctly, this code is unsafe. If the second argument to B 's constructor is constructed first using the move constructor, then a now contains a nullptr and the expression a->x will trigger undefined behavior (likely segfault). If the first argument is constructed first, then everything will work as intended. If this were a

Consider the following code: #include <cctype> #include <functional> #include <iostream> int main() { std::invoke(std::boolalpha, std::cout); // #1 using ctype_func = int(*)(int); char c = std::invoke(static_cast<ctype_func>(std::tolower), 'A'); // #2 std::cout << c << "\n"; } Here, the two calls to std::invoke are labeled for future reference. The expected output is: a Is the expected output guaranteed in C++20? (Note: there are two functions called tolower — one in <cctype> and the other in <locale> . The explicit cast is introduced to select the desired overload.) Short answer No.

The C++ Programming Language 3rd edition by Stroustrup says that, Subtraction of pointers is defined only when both pointers point to elements of the same array (although the language has no fast way of ensuring that is the case). When subtracting one pointer from another, the result is the number of array elements between the two pointers (an integer). One can add an integer to a pointer or subtract an integer from a pointer; in both cases, the result is a pointer value. If that value does not point to an element of the same array as the original pointer or one beyond, the result of using

I have written a program that prints a table. I have not included the return syntax in the main function, but still whenever I type echo $? it displays 12. My source code : #include <stdio.h> int main(void) { int ans,i,n; printf("enter the no. : "); scanf("%d",&n); for(i=1;i<=10;i++) { ans = n*i; printf("%d * %d = %d\n",n,i,ans); } } I have not written return 12, but still it returns 12 every time I execute the program. Thanks. As swegi says, it's undefined behavior. As Steve Jessop et al say, it's an unspecified value until C89, and specified in C99 (the observed behavior is non-conformant to

Although there is plentiful of links about this subject on SO, I think that there is something missing: a clear explanation in plain language of what are the differences between unspecified behavior (UsB), undefined behaviour (UB) and implementation-defined behavior (IDB) with detailed but easy explanation of any use-case and example. Note: I made the UsB acronym up for sake of compactness in this WIKI, but don't expect to see it used elsewhere. I know this may seem a duplicate of other posts (the one it comes closer is this ), but before anyone marks this as a duplicate , please consider what