The function read_long_string(), defined below, contains an error that may be particularly visible under heavy stress. Which one of the following describes it?

int read_long_string (const char ** const buf) {
char * p = NULL;
const char * fwd = NULL;
size_t len = 0;
assert(buf);
do
{
p = realloc(p, len += 256);
if (!p)
return 0;
if (!fwd)
fwd = p;
else
fwd = strchr(p, '\0');
} while (fgets(fwd, 256, stdin));
*buf = p;
return 1;
}

1. The write to *buf is blocked by the const qualifications applied to its type.
2. 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.
3. The symbol stdin may not be defined on some ANCI C compliant systems.
4. The else causes fwd to contain an errant address.
5. If the call to realloc() fails during any iteration but the first, all memory previously allocated by the loop is leaked.

FILE *f = fopen( fileName, "r" );
readData( f );
if( ???? )
{
puts( "End of file was reached" );
}

1. if == EOF[Ans]
2. feof( f )
3. eof( f )
4. if == NULL
5. !f

1. Deprecated by Standard C
2. Internal to the current translation unit
3. Visible to all translation units
4. Read-only subsequent to initialization
5. Allocated on the heap[Ans]

Read a double value from fp.
double read_double (FILE * fp) {
double d;
assert(fp != NULL);
fscanf(fp, " %lf", d);
return d;
}

1. fscanf() will fail to match floating-point numbers not preceded by whitespace.
2. The format specifier %lf indicates that the corresponding argument should be long double rather than double.
3. The call to fscanf() requires a pointer as its last argument.
4. The format specifier %lf is recognized by fprintf() but not by fscanf().
5. d must be initialized prior to usage.

1. ___S
2. 1___ [Ans]
3. ___1
4. ___
5. S___

1. long double
2. Unspecified
3. loat[Ans]
4. double
5. signed float

1. They are generally treated differently by preprocessors and compilers from other identifiers.
2. They are case-insensitive.
3. They are reserved for usage by standards committees, system implementers, and compiler engineers.
4. Applications programmers are encouraged to employ them in their own in order to mark certain symbols for internal usage.
5. They are deprecated by Standard C and are permitted only for backward compatibility with older C libraries.

1. fileOpen (filenm, “r”);
2. fileOpen (filenm, “ra”);
3. fileOpen (filenm, “read”);
4. fopen (filenm, “read”);
5. fopen (filenm, “r”);[Ans]

f = fopen( filename, "r" );

1. FILE f;
2. FILE *f;[Ans]
3. int f;
4. struct FILE f;
5. char *f;

1. flush()
2. output()
3. fflush()
4. dump()
5. write()

short int x; assume x is 16 bits in size

1. 127
2. 128
3. 255
4. 32,767 [Ans]
5. 65,536

void crash (void)
{
printf("got here");
*((char *) 0) = 0;
}

1. The C standard says that dereferencing a null pointer causes undefined behavior. This may explain why printf() apparently fails.
2. If the standard output stream is buffered, the library buffers may not be flushed before the crash occurs.
3. printf() always buffers output until a newline character appears in the buffer. Since no newline was present in the format string, nothing is printed.
4. There is insufficient information to determine why the output fails to appear. A broader context is required.
5. printf() expects more than a single argument. Since only one argument is given, the crash may actually occur inside printf(), which explains why the string is not printed. puts() should be used instead.

char * dwarves [] = {
"Sleepy",
"Dopey" "Doc",
"Happy",
"Grumpy" "Sneezy",
"Bashful",
};

1. 4
2. 5[Ans]
3. 6
4. 7
5. 8

1. qsort()
2. bcmp()
3. memcmp()
4. strxfrm()
5. bsearch()

int debug (const char * fmt, ...) {
extern FILE * logfile;
va_list args;
assert(fmt);
args = va_arg(fmt, va_list);
return vfprintf(logfile, fmt, args);
}

1. The ellipsis is a throwback from K&R C. In accordance with Standard C, the declaration of args should be moved into the parameter list, and the K&R C macro va_arg() should be deleted from the.
2. vfprintf() does not conform to ISO 9899: 1990, and may not be portable.
3. Library routines that accept argument lists cause a fault on receipt of an empty list. The argument list must be validated with va_null() before invoking vfprintf().
4. The argument list args has been improperly initialized.
5. Variadic functions are discontinued by Standard C; they are legacy constructs from K&R C, and no longer compile under modern compilers.

char *buffer = "0123456789";
char *ptr = buffer;
ptr += 5;
printf( "%s\n", ptr );
printf( "%s\n", buffer );

1. 0123456789
   56789
2. 5123456789
   5123456789
3. 56789
   56789
4. 0123456789
   0123456789
5. 6789
   0123456789 [Ans]

char * get_rightmost (const char * d)
{
char rightmost [MAXPATHLEN];
const char * p = d;
assert(d != NULL);
while (*d != '\0')
{
if (*d == '/')
p = (*(d + 1) != '\0') ? d + 1 : p;
d++;
}
memset(rightmost, 0, sizeof(rightmost));
memcpy(rightmost, p, strlen(p) + 1);
return rightmost;
}

1. The calls to memset() and memcpy() illegally perform a pointer conversion on rightmost without an appropriate cast.
2. The does not correctly handle the situation where a directory separator ‘/’ is the final character.
3. The if condition contains an incorrectly terminated character literal.
4. memcpy() cannot be used safely to copy string data.
5. The return value of get_rightmost() will be invalid in the caller’s context.

1. -4000 [Ans]
2. -400
3. -40
4. .004
5. .0004

void freeList( struct node *n )
{
while( n )
{
????
}
}

1. n = n->next;
   free( n );
2. struct node m = n;
   n = n->next;
   free( m );
3. struct node m = n;
   free( n );
   n = m->next;
4. free( n );
   n = n->next;
5. struct node m = n;
   free( m );
   n = n->next;

1. Definition allocates storage for a variable, but declaration only informs the compiler as to the variable’s type.
2. Declaration allocates storage for a variable, but definition only informs the compiler as to the variable’s type.
3. Variables may be defined many times, but may be declared only once.[Ans]
4. Variable definition must precede variable declaration.
5. There is no difference in C between variable declaration and variable definition.

int x[] = {1, 2, 3, 4, 5};
int u;
int *ptr = x;
????
for( u = 0; u < 5; u++ )
{
printf("%d-", x[u]);
}
printf( "\n" );

1. *ptr + 3 = 10;
2. *ptr[ 3 ] = 10;
3. *(ptr + 3) = 10;[Ans]
4. (*ptr)[ 3 ] = 10;
5. *(ptr[ 3 ]) = 10;

sum_array() has been ported from FORTRAN. No * logical changes have been made
double sum_array(double d[],int n)
{
register int i;
double total=0;
assert(d!=NULL);
for(i=l;i<=n;i++)
total+=d[i];
return total;
}

1. The range of the loop does not match the bounds of the array d.
2. The loop processes the incorrect number of elements.
3. total is initialized with an integer literal. The two are not compatible in an assignment.
4. The above fails to compile if there are no registers available for i.
5. The formal parameter d should be declared as double * d to allow dynamically allocated arrays as arguments.

#include
void func()
{
int x = 0;
static int y = 0;
x++; y++;
printf( "%d -- %d\n", x, y );
}

int main()
{
func();
func();
return 0;
}

1. 1 -- 1
   1 -- 1
2. 1 -- 1
   2 -- 1
3. 1 -- 1
   2 -- 2
4. 1 -- 0
   1 -- 0
5. 1 -- 1
   1 -- 2 [Ans]

int fibonacci (int n)
{
switch (n)
{
default:
return (fibonacci(n - 1) + fibonacci(n - 2));
case 1:
case 2:
}
return 1;
}

1. For some values of n, the environment will almost certainly exhaust its stack space before the calculation completes.
   [Ans]
2. An error in the algorithm causes unbounded recursion for all values of n.
4. A break statement should be inserted after each case. Fall-through is not desirable here.
5. The fibonacci() function includes calls to itself. This is not directly supported by Standard C due to its unreliability.

Since the default case is given first, it will be executed before any case matching n.

1. The variable's address [Ans]
2. The variable's right value
3. The variable's binary form
4. The variable's value
5. The variable's format

short int x; assume x is 16 bits in size