What does ": - -" mean in C language?

!! is an old trick to convert numeric values to booleans.

• The first ! negates the value, if it is 0 it will 1 , if it is anything else it will 0 .
• Second ! deny this again

The next part is to use this in defining a bit field in a struct .

When defining an integer numeric field in a struct you can say how many bits it will occupy:

struct Fields {
    int a: 6; //Ocupa 6 bits
    int b: 2; //Ocupa 2 bits
}; 

And the number of bits can not be negative. So - before !! : If e is non-zero we would have a bit field with negative size, which gives compilation error. If e is zero we will have a bit field of size zero, which is valid, although it does not have much use. But since it's all a set of macros to check for constants at compile time it turns out to be useful.

!! is the double negation. It is a trick used in some languages to convert a result to boolean. The first ! (counting from right to left) negates the expression (e) with an implicit cast to boolean, and the second ! denies again.

The - is a simple mathematical operator of subtraction.

Then, if e is false, an integer with 0 of width struct{int: 0;} is defined. If e is true, an integer with negative width struct{int: -1;} is defined, causing a compilation error.

In a bitfield structure you can specify the bit size of each member while retaining its original characteristics. Example:

struct bitfield {
    signed int a : 3; // Um inteiro usando complemento de dois com 3 bits. Entre -4 e 3.
    unsigned b : 4;   // Um inteiro sem sinal. Valores entre 0 e 15.
};

And since there is no padding between members 1 (only at the end) is commonly used on hardware interfaces or to read some types of files.

The detail is that the expression denoting the size of each member is not an integral literal, but rather a constant expression that results in an integral 2 . So the following is valid:

struct bitfield {
    int a : 1+1;
};

The rule also states that if the size is zero the member will have no effect (it will not actually exist) and that size can not be negative. I can then create a macro like this:

#define ERROR_IF_NEGATIVE(e) struct { int : e; };

Notice the omission of the struct and member name. But of course, this macro will fail with very large values (that exceed the size in bits in an int). We can improve a bit by using double negation. !!e is 0 if e is 0 and 1 if e is any other value. So we can -!!e to get a negative value if the condition is true.

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

But note that this macro can be used only where defining a structure is valid, but not in the middle of other expressions. This is where sizeof enters. In C, the% w of an empty structure is always sizeof 3 :

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

Now you can use in the middle of any expression. If the condition is true you will have a compilation error. Otherwise the result will be zero.

int a = 4 + ZERO_UNLESS(sizeof(int) > 2);

This type of macro is similar to 0 , but the condition must be a constant expression and will be evaluated at compile time, generating no performance cost. The operation is equivalent to assert of C ++ 11.