Comments on: ISO/IEC 9899:1999 (E) § 6.7.5.3.7

By: Julian Stecklina

Julian Stecklina — Fri, 21 Sep 2007 21:37:19 +0000

Another “misfeature” in the Core language is this:

int main()
{
int i = 0;
{
int i = i + 1;
printf(“%d\n”, i);
}
return 0;
}

Does another language have such broken scoping rules?

By: behdad

behdad — Tue, 11 Sep 2007 02:19:03 +0000

Indeed, the “pass by reference” trick:

http://mces.blogspot.com/2005/08/pass-by-reference-in-c.html

I got to find this by trying to figure out how setjmp() is implemented as a function…

If you need to pass it that bad, stuff the array in a struct. It’s typically a very bad idea to typedef an array, and the only useful case I’ve seen of it this very jmp_buf and va_list kind of types…

By: Swfblag » Blog Archive » Thank you

Swfblag » Blog Archive » Thank you — Fri, 24 Aug 2007 23:42:28 +0000

[...] Ryan for dvalue. And for knowing all this stuff about C. [...]

By: desrt

desrt — Thu, 23 Aug 2007 17:36:20 +0000

evil *x is int (*x)[1].

int (*x)[1] is a pointer to an array (ie: the pointer points at the first element of the array).

int **x is a pointer to a pointer to an array (ie: the pointer points at a pointer that points at the first element of the array).

By: Steven Walter

Steven Walter — Thu, 23 Aug 2007 17:33:29 +0000

I’m not convinced that the “obvious” solution is wrong. “the code is very clearly in error (since x is already a pointer).” There’s nothing wrong with using the address-of operator on a pointer. It seems to me that the type would even work out, because takes_evil_ptr would expect evil *, i.e. int **, no?

By: James Henstridge

James Henstridge — Thu, 23 Aug 2007 03:04:12 +0000

Sean: the typedef Ryan is complaining about was not defined by him: va_list is defined by the C standard, but its type is not. Further more, it actually is defined differently on different platforms. It could be a pointer, array or something else.

If the aim is to copy a va_list and you’re using glib, G_VA_COPY() is the best option.

By: Sean

Sean — Thu, 23 Aug 2007 01:42:24 +0000

This isn’t a bug in C or a misfeature, really. It’s (to put bluntly) you misusing typedefs. Typedefs do not define new types. They merely provide an alias. For the most part (not entirely, of course) the two following lines of C code are equivalent:

typedef foo bar;

#define bar foo

By: Peter

Peter — Thu, 23 Aug 2007 01:10:28 +0000

Not sure if you’re wanting to use C++ for this, but std::vector and friends make this so amazingly simpler. :P

By: Joe Buck

Joe Buck — Wed, 22 Aug 2007 23:21:54 +0000

The original blog posting is right; the non-orthogonal handling of arrays is a wart. They had their reasons; passing general arrays by value would have required some heavyweight mechanism, and there are advantages to being able to convert an array to a pointer to its first element, but it means you can’t treat an array like other types.

You can embed an array in a struct:

typedef struct {
int data[4];
} four_ints;

By: Pedro Côrte-Real

Pedro Côrte-Real — Wed, 22 Aug 2007 23:15:52 +0000

The reason you can’t pass arrays as values is that since parameters size has to be fixed (va_args being the notable exception) you’d have to call the function with an array with a fixed size. Your function definition would have to be something like:

foo(int bar[10])

and you’d always have to pass an array of size 10. Passing structures by value works exactly because structures have a fixed size. They can contain arrays but only fixed sized ones.

The only reason this works with va_args is that the variable part is always the last arguments and its up to the function to know when to stop reading the stack by reading the arguments. That’s why you can’t have va_args functions that take 0 or more arguments since you need at least one to know if there’s any more (printf is a good example of this).

You could argue that you should be able to pass fixed sized arrays as arguments but you can easily trick the compiler into letting you. Just define a structure with only the array in it and you can then use C’s weak typing to pass an actual array instead of the structure. You might need some ugly casting to shut up the compiler though.