9

Why and where does C standard allow this code compile? where is it useful?

struct foo { int : 12; };
Improve this question
3
  • I was thinking the @Carl Norum's answer useful (as usual) why was it removed? Commented Oct 4, 2013 at 21:51
  • A comment under the deleted answer gives a C11 citation that such a structure invokes undefined behavior, revealed in ouah's answer. Then a comment is given that the answer is deleted for that reason. Commented Oct 5, 2013 at 1:52
  • Does this answer your question? Bitfields in C without variable name Commented Apr 4, 2023 at 13:07

3 Answers 3

Reset to default
6

That would be in §6.7.2.1 Structure and union specifiers

12) A bit-field declaration with no declarator, but only a colon and a width, indicates an unnamed bit-field.126

The footnote explains why such things exist:

126 An unnamed bit-field structure member is useful for padding to conform to externally imposed layouts.

That being said, the same part of the standard (paragraph 8) also states:

If the struct-declaration-list does not contain any named members, either directly or via an anonymous structure or anonymous union, the behavior is undefined.

But some compilers (GCC and clang at least) allow this anyway, as an extension.

The use is a bit limited if that's the only bitfield in the struct, but not impossible to use as ouah illustrates.

The standard continues on with another "oddity":

As a special case, a bit-field structure member with a width of 0 indicates that no further bit-field is to be packed into the unit in which the previous bitfield, if any, was placed.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

And since the behavior is undefined by the standard, it will probably be treated differently by every compiler, just for added confusion^H^H^H^H^H^H^H^H^Hfun.
6

This program invokes undefined behavior.

C says:

(C99, 6.7.2.1p7) "[...] If the struct-declaration-list contains no named members, the behavior is undefined."

Now some compilers accept it as an extension. How can this be useful?

For example for Linux kernel famous BUILD_BUG_ON_ZERO macro:

#define BUILD_BUG_ON_ZERO(e) (sizeof(struct { int:-!!(e); }))

To see what does this macro, you can look here.

Improve this answer

6 Comments

Though the BUILD_BUG_ON_ZERO macro uses a struct type which contains no names, it doesn't look like the trick is relying on this in any way (other than that not using names is more hygienic than using names). They key is that a failed expression produces a negative value for the bitfield size, which is diagnosed.
@Kaz It actually uses it. The macro would not work in GNU C with a named member. C does not allow named bit-field of width of 0, only unnamed bit-field. And GNU C also does not allow it: gcc stops translation with an named bit-field of width of 0.
but you could add another dummy structure member with a name, surely.
@Kaz No, you cannot add another dummy named member. BUILD_BUG_ON_ZERO has to bug if e is non-zero and has to yield 0 if e is 0. See for example Linux ARRAY_SIZE macro implementation which assumes this and uses BUILD_BUG_ON_ZERO as an identity element when e is 0. By adding a dummy named member (which cannot have a 0 width as we saw above), you can no longer fill the constraint of having a BUILD_BUG_ON_ZERO yielding 0 when e is 0.
You can easily bend the expression to return zero. #define BUILD_BUG_ON_ZERO(e) (<standard-conforming hack here>, 0) or #define BUILD_BUG_ON_ZERO(e) ((<standard-conforming-hack>) * 0) etc. It doesn't matter what the hack returns; all we care is whether it blows up at compile time or not.
|
3

Well, according to the language specification, if your program contains a struct type without named members, the behavior is undefined. (To the question of why it is not officially recognized as a constraint violation I have no immediate answer.) It is stated in 6.7.2.1/7

The struct-declaration-list is a sequence of declarations for the members of the structure or union. If the struct-declaration-list contains no named members, the behavior is undefined.

Other than that such declaration is not really "useful" since the only thing it produces is undefined behavior.

Improve this answer

5 Comments

By my understanding, some compilers offer a language extension which permits structures to have anonymous members, and imports the names of those members into the namespace of the enclosing struct. Since the standard doesn't specify that the named members of the interior struct members would be considered named members of the external one, would that imply that the standard would forbid a struct whose members were all anonymous imported structs?
@supercat: I'm not sure I understand you correctly. Some compilers do indeed allow anonymous struct members (with the behavior you describe), but this is a non-standard extension. C language does not support anonymous struct members. That's all the standard has to say about it.
I just saw your update. Perhaps my comment above provides a reason it's not a constraint violation: a compiler might as a language extension provide a useful meaning to a struct with no named members. Language constructs which have no defined meaning but for which which some compilers might possibly define some useful meaning are better left as UB than as constraint violations, even if it would be a good idea for any compiler that doesn't define a useful meaning to issue a diagnostic.
My point is that if the standard says some construct X is undefined behavior, then a compiler vendor can offer a fully-standards compliant compiler which is specified by the vendor to implement X in some useful fashion. By contrast, if the standard says X is a constraint violation, then a standards-compliant compiler would be forbidden from having that construct do something useful.
@supercat: Well, firstly, when the language authors anticipate the potential usability of some formally forbidden construct, they usually leave it as "implementation-defined behavior". Secondly, many compilers do provide numerous extensions that are based on constraint-violating code. When it comes to extensions, implementations are allowed to do absolutely anything as long as it does not alter any conforming behavior.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.