A nice, little known C feature: Static array indices in parameter declarations

I am convinced there is some kind of long-term drinking game going on in the C standards committee to see how many different uses they can come up with for the word "static".

In C++, you can do this by passing the array by reference:<p><pre><code> void foo(int (&#38;foo)[10]) {} </code></pre> However, that is not "minimum of 10" but "exactly 10".<p>You can also get the size at compile time:<p><pre><code> template &#60;size_t N&#62; void foo(int (&#38;foo)[N]) { int newarry[N+2]; } </code></pre> I've used the above for something like this:<p><pre><code> template &#60;size_t N&#62; void safe_strcpy(char (&#38;buf)[N], const char *src) { strncpy(buf, src, N-1); buf[N-1] = 0; }</code></pre>

Doesn't seem to work for me using GCC 4.7.2.<p>flags: -g -Wall -Wextra -std=c99 -pedantic<p>The following code compiles and runs (for me at least) with no errors. Tried with both stack and heap allocated arrays of various sizes.<p><pre><code> #include &#60;stdlib.h&#62; void foo(int array[static 10]) { (void) array; // suppress unused var compiler warning return; } int main () { int *x = calloc(10, sizeof(int)); int *y = calloc(9, sizeof(int)); int *z = calloc(11, sizeof(int)); foo(x); foo(y); foo(z); foo(NULL); int a[9]; int b[4]; int c[11]; foo(a); foo(b); foo(c); return 0; }</code></pre>

Can someone recommend a resource that talks about some interesting C stuff similar to this? I've looked at "Expert C Programming: Deep C Secrets" but found it a bit outdated. And the C standard is a bit dry :-).

Unfortunately, gcc does not warn. I can pass a NULL pointer and arrays that are too small. But on the other hand, there is very little use, because arrays usually contain an arbitrary number of elements. This might be useful for matrices and vectors, but then I would rather wrap them in a struct anyway.

I thought I knew C.

great, just what we need - yet another overload of the static keyword :-).

Why do many features added to C after the first standard have to be quirky and slightly incompatible (with C++, with existing implementations, etc.) like this?<p>Other examples are inline (different from C++, makes use of weird combinations with static and extern) and tgmath (compiler magic inaccessible to user-defined functions until C11).<p>They also seem to __barely__ improve the language without ever being "cool" or "interesting".<p>At least C++ has some standard data structures...<p>PS: Even Python has binary literals, while they were deemed "not useful enough" for C.

I've never seen this before:<p><pre><code> void bar(int myArray[static 10]) </code></pre> Is that standard, and if so, how long has it been?<p>I also ran across this construct in a quick search [1]:<p><pre><code> void bar(int myArray[const]) </code></pre> [1] <a href="http://stackoverflow.com/questions/3693429/c-parameter-array-declarators" rel="nofollow">http://stackoverflow.com/questions/3693429/c-parameter-array...</a>

Interesting, but the one comment I haven't seen yet on this thread is 'Why is this useful enough to be a compiler feature?'. I think this is especially relevant with a relatively slim language like C.<p>In the rare cases you need to do this sort of check why not just write a simple sizeof test?

Using 'static' in this way <i>compiles</i> with both Oracle Studio 12 and IBM xlc 11, but neither exhibit the behavior that gcc is shown to have in the article. Passing in both NULL as well as an array of shorter length work just fine with no warning/error from the compiler.<p>So, YMMV.

[I'm away from a C compiler and can't test]:<p>What happen if you do<p>void bar(int fooArray[static 0]) {} ?<p>Is NULL allowed?

Live test case: <a href="http://liveworkspace.org/code/2uk7hc$18" rel="nofollow">http://liveworkspace.org/code/2uk7hc$18</a>

a bit off-topic: Golang has a similar feature built into it's type system [1]<p>"The size of an array is part of its type. The types [10]int and [20]int are distinct."<p>[1] <a href="http://golang.org/doc/effective_go.html#arrays" rel="nofollow">http://golang.org/doc/effective_go.html#arrays</a>

This is legitimately awesome, and allows for cleaner code. Nice post!