x = 0

x = 1

x = 4

x = 5

x = 6

go_cart

go4it

4season

run4

what

z = 0.00

z = 1.00

z = 1.50

z = 2.00

z = NULL

6

7

8

9

The code will not compile

11

12

13

20

21

Stdout and stderr

Console and error

Stdout and stdio

Stdio and stderr

Errout and conout

int *ptr = (int *) malloc(10, sizeof(int));

int *ptr = (int *) calloc(10, sizeof(int));

int *ptr = (int *) malloc(10*sizeof(int));

int *ptr = (int *) alloc(10*sizeof(int));

int *ptr = (int *) calloc(10*sizeof(int));

enum coin {(penny,1), (nickel,5), (dime,10), (quarter,25)};

enum coin ({penny,1}, {nickel,5}, {dime,10}, {quarter,25});

enum coin {penny=1,nickel=5,dime=10,quarter=25};

enum coin (penny=1,nickel=5,dime=10,quarter=25);

enum coin {penny, nickel, dime, quarter} (1, 5, 10, 25);

Standard C defines this particular behavior as implementation-dependent. The compiler writer has the freedom to decide how the remaining elements will be handled.

The remaining elements are initialized to zero(0).

It is illegal to initialize only a portion of the array. Either the entire array must be initialized, or no part of it may be initialized.

As with an enum, the compiler assigns values to the remaining elements by counting up from the last explicitly initialized element. The final four elements will acquire the values 4, 5, 6, and 7, respectively.

They are left in an uninitialized state; their values cannot be relied upon.

1, 2, 2

1, 2, 4

1, 2, 8

2, 2, 4

2, 4, 8

They are always 32-bit values.

For efficiency, pointer values are always stored in machine registers.

With the exception of generic pointers, similarly typed pointers may be subtracted from each other.

A pointer to one type may not be cast to a pointer to any other type.

With the exception of generic pointers, similarly typed pointers may be added to each other.

if (x == 0) return 0;

return 1;

if (x >= 2) return 2;

if (x == 0) return 1;

if (x <= 1) return 1;

The variable's value.

The variable's binary form.

The variable's address.

The variable's format.

The variable's right value.

The global variable is referenced via the extern specifier.

The global variable is referenced via the auto specifier.

The global variable is referenced via the global specifier.

The global variable is referenced via the pointer specifier.

The global variable is referenced via the ext specifier.

Ident

Auto

BigNumber

G42277

Peaceful_in_space

X() effectively rounds f to the nearest integer value, which it returns.

X() effectively performs a standard typecast and converts f to a roughly equivalent integer.

X() preserves the bit-pattern of f, which it returns as an unsigned integer of equal size.

Since u.n is never initialized, X() returns an undefined value. This function is therefore a primitive pseudo random number generator.

Since u.n is automatically initialized to zero (0) by the compiler, X() is an obtuse way of always obtaining a zero (0) value.

*p++ causes p to be incremented before the reference is performed because both operators have equal precedence and are right associative.

An array is a non-modifiable value, so p cannot be incremented directly. A navigation pointer should be used in conjunction with p.

*p++ causes p to be incremented before the dereference is performed, because the auto-increment operator has higher precedence than the indirection operator.

The condition of a while loop must be a Boolean expression. The condition should be n != 0.

An array cannot be initialized to a variable size. The subscript n should be removed from the definition of the parameter p.

f == EOF

feof( f )

eof( f )

f == NULL

!f

Deprecated by Standard C.

Internal to the current translation unit.

Visible to all translation units.

Read-only subsequent to initialization.

Allocated on the heap.

The __P() macro has no function, and merely obfuscates library function declarations. It should be removed from further releases of the C library.

The __P() macro provides forward compatibility for C++ compilers, which do not recognize Standard C prototypes.

Identifiers that begin with two underscores are reserved for C library implementations. It is impossible to determine the purpose of the macro from the context given.

The __P() macro provides backward compatibility for K&R C compilers, which do not recognize Standard C prototypes.

The __P() macro serves primarily to differentiate library functions from application-specific functions.

fscanf() will fail to match floating-point numbers not preceded by whitespace.

The format specifier %lf indicates that the corresponding argument should be long double rather than double.

The call to fscanf() requires a pointer as its last argument.

The format specifier %lf is recognized by fprintf() but not by fscanf().

D must be initialized prior to usage.

The write to *buf is blocked by the const qualifications applied to its type.

If the null pointer for char is not zero-valued on the host machine, the implicit comparisons to zero (0) may introduce undesired behavior. Moreover, even if successful, it introduces machine-dependent behavior and harms portability.

The symbol stdin may not be defined on some ANCI C compliant systems.

The else causes fwd to contain an errant address.

If the call to realloc() fails during any iteration but the first, all memory previously allocated by the loop is leaked.

Long double

Unspecified

Float

Double

Signed float

They are generally treated differently by preprocessors and compilers from other identifiers.

They are case-insensitive.

They are reserved for usage by standards committees, system implementers, and compiler engineers.

Applications programmers are encouraged to employ them in their own code in order to mark certain symbols for internal usage.

They are deprecated by Standard C and are permitted only for backward compatibility with older C libraries.

___S

1___

___1

S___