Handling a variable number of parameters M2 Test

Handling a variable number of parameters M2 Test

1. What is the expected output of the following program?

   #include <stdio.h>
   double x(double x, ...) {
       va_list 1;
       double s = x, v;
       va_start(1,x);
       do {
             v = va_arg(1,double);
             s += v;
        } while(v != 0.0);
        return s;
   }
   int main(void) {
        printf("%f\n",x(-2., -1., 0., 1., 2., 0.));
        return 0;
   }

   • -3.000000
   • 3.000000
   • -2.000000
   • 2.000000

2. A macro writing a formatted string to the stderr stream may be implemented as:

   • #define PREE(...)    fprintf(stderr, "__VA_ARGS__")
   • #define PREE(...)    fprintf(stderr, __VA_ARGS__)
   • #define PREE(...)    fprintf(stderr, #__VA_ARGS__)
   • #define PREE(...)    fprintf(stderr, ...)

3. Which of the following function headers is invalid?

   • void f0(char *s, int n, ...)
   • void f0(int n, ..., char *s)
   • void f0(int n, char *s, ...)
   • void f0(int n, char *s)

4. Only one of the following macro definitions is valid-which one?

   • #define VARMAC(...)      fprintf(x, __VA_ARGS__)
   • #define VARMAC(...,x)    fprintf(x, __VA_ARGS__)
   • #define VARMAC(x)        fprintf(x, __VA_ARGS__)
   • #define VARMAC(x, ...)   fprintf(x, __VA_ARGS__)

5. The stack (understood as an abstract data type) is often referred to as:

   • LIFO
   • FIFO
   • LILO
   • FILO

6. A header file, needed for a variadic argument list processing, is named:

   • stdvar.h
   • vararg.h
   • varstd.h
   • stdarg.h

7. What is the expected output of the following program?

   #include <stdarg.h>
   #include <stdio.h>
   int f(int n, ...) {
       va_list list;
       va_start(list,n);
       n = va_arg(list,int);
       va_end(list);
       return n;
   }
   int main(void) {
        printf("%f\n", f(1, 2, 3, 0));
        return 0;
   }

   • 1
   • 3
   • 0
   • 2

8. A list of values stored in a variable of type va_list may be passed to a function as an argument, but the variable:

   • must not be passed as the last argument
   • must be properly instantiated before the invocation by means of the va_start() function
   •  must not be only argument
   • must not be passed as the first argument

9. What is the expected output of the following code?

   #include <stdio.h>
   #define VMAC(...)   printf("%s\n", #___VA_ARGS__)
   int main(void) {
        char *s = "macro";
        VMAC(s,s,s);
        return 0;
   }

   • macro,macro,macro
   • s,s,s
   • macromacromacro
   • sss

10. Which of the following snippets should be put into the code to make it work properly?

    #include <stdarg.h>
    #include <stdio.h>
    int sum(int n, ...) {
        va_list list;
        double s = 0;
        va_start(list,n);
        while(n--) {
              s += va_arg(list,double);
        }
        va_end(list);
        return s;
    }
    int main(void) {
         double v;
         /* put a line here */
         printf("%f\n", v);
         return 0;
    }

    • v = sum(3, 1., 2., 3.);
    • v = sum(3, 1., 2.);
    • v = sum(3, 1.);
    • v = sum(3, 1L, 2L, 3L);

11. What is the expected output of the following program?

    #include <stdio.h>
    double x(double x, double y, double z, ...) {
        va_list 1;
        double s = x, v;
        va_start(1,z);
        do{
           v = va_arg(1,double);
           s += v;
        }while(v != 0.0);
         return s;
    }
    int main(void) {
         printf("%f\n",x(-2., -1., 0., 1., 2., 0.));
         return 0;
    }

    • 1.000000
    • 0.000000
    • -2.000000
    • 3.000000

12. The va_arg , an identifier coming form <stdarg.h>, is actually a:

    • variable
    • type
    • macro
    • function

13. In the stdcall argument passing convention:

    • the stack is cleaned periodically by the OS
    • the stack is always clean
    • the invokee cleans the stack
    • the invoker cleans the stack

14. Copying one instance of va_list to another is done by the:

    • strcpy() function
    • va_copy() function 
    • memcpy() function
    • memmove() function

15. The term “cdecl” refers to the name of:

    • an obsolete version of the “C” programming language
    • a contemporary version of the “C” programming language
    • a way of passing arguments to a function
    • an obsolete family of compilers

16. The “Pascal” argument passing convention relies on the assumption that:

    • arguments are transferred through a stack (the first argument on a list is put at the bottom of the stack)
    • arguments are transferred through a shared memory block
    • arguments are transferred through the CPU registers
    • arguments are transferred through a stack (the first argument on a list is put at the top of the stack)

17. A function with the following header:

    int max(int n, va_list vals)

    •  needs a va_start (n, vals) invocation at the boy’s beginning
    • needs a va_start(vals) invocation at the boy’s begining
    • doesn’t need a va_start() invocation
    • needs a  va_start(vals, n) invocation at the body’s beginning

18. The vsprintf() function has the following prototype:

    • int vsprintf(char *format, va_list ap);
    • int vsprintf(char *str, char *format, ...);
    • int vsprintf(char *str, char *format, va_list ap);
    • int vsprintf(char *str, chat *format);

19. A variable function is a function which:

    • accepts more than one invocation at a time
    • changes its name during program execution
    • changes its address during program execution
    • accepts a varying number of arguments

20. The following trigraph is named:

    ...

    • a parabola 
    • an ellipsis
    • a three dot
    • a hyperbole