fg

efg

defg

cdefg

None of the above

1

2

3

4

5

int *x; *x = 0x200;

int *x = &0x200;

int *x = *0x200;

int *x = 0x200;

int *x( &0x200 );

0

1

2

3

4

char ** (* p) [12][12] = array;

char ***** p = array;

char * (* p) [12][12][12] = array;

const char ** p [12][12][12] = array;

char (** p) [12][12] = array;

• 3 : 4 - 4 : 3

• 4 : 4 - 3 : 3

• 4 : 4 - 3 : 3
  

• 4 : 3 - 3 : 4

• 3 : 3 - 4 : 4

4

5

6

7

8

Localtime

Gmtime

Strtime

Asctime

Ctime

It will not compile because not enough initializers are given.

6

7

12

24

ptr = realloc( ptr, 10 * sizeof( struct customer));

realloc( ptr, 9 * sizeof( struct customer ) );

ptr += malloc( 9 * sizeof( struct customer ) );

ptr = realloc( ptr, 9 * sizeof( struct customer ) );

realloc( ptr, 10 * sizeof( struct customer ) );

Pointer arithmetic is permitted on pointers of any type.

A pointer of type void * can be used to directly examine or modify an object of any type.

Standard C mandates a minimum of four levels of indirection accessible through a pointer.

A C program knows the types of its pointers and indirectly referenced data items at runtime.

Pointers may be used to simulate call-by-reference.

typedef void (*sighandler_t) (int);

typedef sighandler_t void (*) (int);

typedef void *sighandler_t (int);

#define sighandler_t(x) void (*x) (int)

#define sighandler_t void (*) (int)

@@

||

AND

&&

OR

clearerr()

fseek()

ferror()

feof()

setvbuf()

The first definition certainly allows the contents of buf to be safely modified at runtime while the second definition does not.

The first definition is not suitable for usage as an argument to a function call but the second definition is.

The first definition is not legal because it does not indicate the size of the array to be allocated while the second definition is legal.

They do not differ -- they are functionally equivalent.

The first definition does not allocate enough space for a terminating NUL-character, nor does it append one while the second definition does.

c = getc();

getc( &c );

c = getchar( stdin );

getchar( &c )

c = getchar();

%e always displays an argument of type double in engineering notation; %f always displays an argument of type double in decimal notation.

%e expects a corresponding argument of type double; %f expects a corresponding argument of type float.

%e displays a double in engineering notation if the number is very small or very large. Otherwise, it behaves like %f and displays the number in decimal notation.

%e displays an argument of type double with trailing zeros; %f never displays trailing zeros.

%e and %f both expect a corresponding argument of type double and format it identically. %e is left over from K&R C; Standard C prefers %f for new code.

=

,

[]

^

->

There will be a memory overwrite.

There will be a memory leak.

There will be a segmentation fault.

Not enough space is allocated by the malloc.

It will not compile.

It automatically initializes a variable to 0.

It indicates that a variable's memory will automatically be preserved.

It automatically increments the variable when used.

It automatically initializes a variable to NULL.

It indicates that a variable's memory space is allocated upon entry into the block.

It will not compile.

It will print out: i=9.

It will print out: i=10.

It will print out: i=11.

It will loop indefinitely

#include <sysheader.h>

#incl "sysheader.h"

#includefile <sysheader>

#include sysheader.h

#incl <sysheader.h>

%- 30.4e

%4.30e

%-4.30f

%-30.4f

%#30.4f