c11

Apparently the following function prototypes are valid in C99 and C11: void foo(int a[const *]); void bar(int a[static volatile 10]); What is the purpose of those strange subscript notations * , static , and CV qualifiers? Do they help distinguish statically typed arrays from variable-length arrays? Or are they just syntactic sugar? static in parameter array declarator void f(int a[static 10]); static here is an indication that parameter a is a pointer to int but that the array objet (where a is a pointer to its first element) has at least 10 elements. A compiler has then the right to assume f

According to C11 WG14 draft version N1570 : The header <ctype.h> declares several functions useful for classifying and mapping characters. In all cases the argument is an int , the value of which shall be representable as an unsigned char or shall equal the value of the macro EOF . If the argument has any other value, the behavior is undefined. Is it undefined behaviour?: #include <ctype.h> #include <limits.h> #include <stdlib.h> int main(void) { char c = CHAR_MIN; /* let assume that char is signed and CHAR_MIN < 0 */ return isspace(c) ? EXIT_FAILURE : EXIT_SUCCESS; } Does the standard allow

_s functions, such as scanf_s , printf_s seems to be optional standard. MSVC has implemented these functions, but gcc hasn't. Is there specific reason for not implementing secure functions? Is scanf of gcc secure enough? The _s functions are optional ( Annex K of the C11 standard ). They're widely regarded as 'not very beneficial'. In the answers to my question Do you use the TR-24731 "safe" functions? , you can find information about where there are problems with the standard specification — such as crucial differences between the standard and Microsoft's implementation. TR 24731-1 was a

I just did a experiment yesterday, and find something confusing: #include <stdio.h> int main() { int j; scanf("%d",&j); const int i = j; int arr[i]; return 0; } The number j is read from keyboard and it’s used to allocate the array arr on the stack. The compiler does not even know the size of the array at compile time (initializes j to 0?), but there is no compilation error. How is it possible? Variable length arrays were added to C99. It's described in the C99 rationale: 6.7.5.2 Array declarators C99 adds a new array type called a variable length array type. The inability to declare arrays

C11 specifies in section 6.7 which declarations are also definitions: A definition of an identifier is a declaration for that identifier that: — for an object, causes storage to be reserved for that object; [...] I didn't find a comprehensive list of which object declarations cause storage to be reserved. Intuitively it is clear to me, but I wasn't able to get this information out of the C11 standard. There's no definitive list because the standard just describes what are definitions and it's not in a single place. I'll try to sum it up here. I'll only use the type int here without any

C11 supports anonymous structures, like so: struct Foo { struct { size_t x, y; }; }; struct Foo f; f.x = 17; f.y = 42; Basically, the members of such a struct are treated as if they were members of the enclosing struct or union (recursively, if the enclosing structure was itself anonymous). What was the rationale for C++11 not also including anonymous structures? They're only uncommonly useful (mostly inside unions, to eliminate the typing of an identifier for the struct ), certainly. But they seem an obvious enough addition to the specification (and one already implemented by many compilers)