Command Line Arguments Questions and Answers

Q: Comment on the following pointer declaration? int *ptr, p;

Correct answer: ptr is a pointer to integer, p is notThe * binds to the declarator, not to the type, so it applies to ptr alone. p is declared as a plain int.This is why the style int *ptr; - asterisk against the name rather than the type - is often preferred: it makes the grouping visible. Declaring two pointers requires the asterisk on each, as int *ptr, *p;, and the mistake here is a classic source of confusion in code that declares several variables at once.

Q: What does argc and argv indicate in command-line arguments?

Correct answer: argument count, argument vectorargc is the argument count - the number of arguments including the program name - and argv is the argument vector, "vector" being the older word for a one-dimensional array.The array holds one char * per argument, with argv[0] naming the program and argv[argc] guaranteed to be a null pointer. The names are conventional rather than mandated; what the compiler requires is the types, an int followed by a char **.

Q: What does the first parameter of the main function represent?

Correct answer: Number of command line argumentsThe first parameter is argc, an int giving how many arguments the program was invoked with - the program name included, so a bare invocation gives 1.The list of the arguments themselves is the second parameter, argv. C has neither dictionaries nor stacks as language constructs, so those options describe nothing the runtime could supply. The count exists because the array itself carries no length, only a null pointer at its end.

Q: What will be the output of the following C code (if run with no options or arguments)? #include <stdio.h> int main(int argc, char *argv[]) { printf("%d\n", argc); return 0; }

Correct answer: 1Run with no options or arguments, argc is 1: the program name in argv[0] is itself counted.The value is not platform-dependent in any practical sense - the standard requires the program name to be represented and counted when it is available - so the second and third options fail. The single theoretical exception is a program started by an exec call passing no name at all, which gives argc of 0, and no shell does that.

Q: Does there exist any way to make the command-line arguments available to other functions without passing them as arguments to the function?

Correct answer: YesThe parameters of main are local to it, but their values need not stay there. The straightforward method is to copy them into file-scope variables at the top of main, after which any function in the translation unit can read them.Some environments also expose them directly: Turbo C provides the globals _argc and _argv, and several Unix systems have equivalents. Either way the answer is yes, though the portable route is the explicit copy into globals of one's own.

Q: What is the output of this C code? #include <stdio.h> int *f(); int main() { int *p = f(); printf("%d\n", *p); } int *f() { int j = 10; return &j; }

Correct answer: Undefined behaviourj is an automatic variable, so its lifetime ends when f returns. The pointer handed back addresses storage that has been reclaimed, and dereferencing it is undefined behaviour.In practice the value often survives long enough to print as 10, because nothing has yet overwritten that part of the stack - but the call to printf itself uses the stack and may destroy it, and the compiler is entitled to assume the situation never arises. Allocating with malloc, as the companion question does, is the correct fix.

Q: What will be the output of the program (myprog.c) given below if it is executed from the command line? cmd> myprog one two three /* myprog.c */ #include <stdio.h> #include <stdlib.h> int main(int argc, char **argv) { printf("%s\n", *++argv); return 0; }

Correct answer: one++argv advances the pointer to argv[1] and yields the new value, so *++argv is argv[1] - the first argument after the program name.With the command line myprog one two three that is the string "one", and %s prints it in full. The pre-increment is what skips the program name: argv[0] holds that, and shifting the pointer past it is a common idiom when a program wants only its arguments.

Q: What is the output of this C code? #include <stdio.h> int main() { char *p = NULL; char *q = 0; if (p) printf(" p "); else printf("nullp"); if (q) printf("q\n"); else printf(" nullq\n"); }

Correct answer: nullp nullqBoth pointers are null. NULL is a null pointer constant, and so is a literal 0 in a pointer context - the compiler converts it, which is why char *q = 0; is legal and gives the same value as = NULL.A null pointer tests false in a condition, so both if statements take their else branch. Note that the internal representation is not required to be all-zero bits; what the standard guarantees is the conversion from the constant 0 and the comparison, which is all the program relies on.

31.

What is the first argument in command line arguments?

A.The number of command-line arguments the program was invoked with;
B.A pointer to an array of character strings that contain the arguments
C.Nothing
D.None of the mentioned

Answer: A

Correct answer: The number of command-line arguments the program was invoked with;

The first parameter of main is argc, an int holding how many arguments the program was invoked with - the program name included, so a bare invocation gives 1.

The second parameter is argv, the array of pointers to the argument strings. Note the wording of the question: it asks about the first parameter of main, not about the first item the user typed, which is the program name and lives in argv[0].

Discuss in Forum

32.

Comment on the following pointer declaration?

int *ptr, p;

A.ptr is a pointer to integer, p is not
B.ptr and p, both are pointers to integer
C.ptr is a pointer to integer, p may or may not be
D.ptr and p both are not pointers to integer

Answer: A

Correct answer: ptr is a pointer to integer, p is not

The * binds to the declarator, not to the type, so it applies to ptr alone. p is declared as a plain int.

This is why the style int *ptr; - asterisk against the name rather than the type - is often preferred: it makes the grouping visible. Declaring two pointers requires the asterisk on each, as int *ptr, *p;, and the mistake here is a classic source of confusion in code that declares several variables at once.

Discuss in Forum

33.

What does argc and argv indicate in command-line arguments?

A.argument count, argument variable
B.argument count, argument vector
C.argument control, argument variable
D.argument control, argument vector

Answer: B

Correct answer: argument count, argument vector

argc is the argument count - the number of arguments including the program name - and argv is the argument vector, "vector" being the older word for a one-dimensional array.

The array holds one char * per argument, with argv[0] naming the program and argv[argc] guaranteed to be a null pointer. The names are conventional rather than mandated; what the compiler requires is the types, an int followed by a char **.

Discuss in Forum

34.

What does the first parameter of the main function represent?

A.Number of command line arguments
B.List of command line arguments
C.Dictionary of command line arguments
D.Stack of command line arguments

Answer: A

Correct answer: Number of command line arguments

The first parameter is argc, an int giving how many arguments the program was invoked with - the program name included, so a bare invocation gives 1.

The list of the arguments themselves is the second parameter, argv. C has neither dictionaries nor stacks as language constructs, so those options describe nothing the runtime could supply. The count exists because the array itself carries no length, only a null pointer at its end.

Discuss in Forum

35.

What will be the output of the following C code (if run with no options or arguments)?

#include <stdio.h>
    int main(int argc, char *argv[])
    {
        printf("%d\n", argc);
        return 0;
    }

A.1
B.Depends on the platform
C.Depends on the compiler

Answer: A

Correct answer: 1

Run with no options or arguments, argc is 1: the program name in argv[0] is itself counted.

The value is not platform-dependent in any practical sense - the standard requires the program name to be represented and counted when it is available - so the second and third options fail. The single theoretical exception is a program started by an exec call passing no name at all, which gives argc of 0, and no shell does that.

Discuss in Forum

36.

Does there exist any way to make the command-line arguments available to other functions without passing them as arguments to the function?

A.Yes
B.No

Answer: A

Correct answer: Yes

The parameters of main are local to it, but their values need not stay there. The straightforward method is to copy them into file-scope variables at the top of main, after which any function in the translation unit can read them.

Some environments also expose them directly: Turbo C provides the globals _argc and _argv, and several Unix systems have equivalents. Either way the answer is yes, though the portable route is the explicit copy into globals of one's own.

Discuss in Forum

37.

Which character is used to separate different arguments?

A.#
B.$
C.space
D.|

Answer: C

Command line arguments are separated by space. So if you write
./output This is a single parameter
then they will interpreted as 5 command line arguments as shown : [“./output”, “This”, “is”, “single”, “parameter”].

Discuss in Forum

38.

What is the output of this C code?

#include <stdio.h>
    int *f();
    int main()
    {
        int *p = f();
        printf("%d\n", *p);
    }
    int *f()
    {
        int j = 10;
        return &j;
    }

A.10
B.Compile time error
C.Segmentation fault/runtime crash
D.Undefined behaviour

Answer: A

Correct answer: Undefined behaviour

j is an automatic variable, so its lifetime ends when f returns. The pointer handed back addresses storage that has been reclaimed, and dereferencing it is undefined behaviour.

In practice the value often survives long enough to print as 10, because nothing has yet overwritten that part of the stack - but the call to printf itself uses the stack and may destroy it, and the compiler is entitled to assume the situation never arises. Allocating with malloc, as the companion question does, is the correct fix.

Discuss in Forum

39.

What will be the output of the program (myprog.c) given below if it is executed from the command line?
cmd> myprog one two three

/* myprog.c */
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
    printf("%s\n", *++argv);
    return 0;
}

A.myprog
B.one
C.two
D.three

Answer: B

Correct answer: one

++argv advances the pointer to argv[1] and yields the new value, so *++argv is argv[1] - the first argument after the program name.

With the command line myprog one two three that is the string "one", and %s prints it in full. The pre-increment is what skips the program name: argv[0] holds that, and shifting the pointer past it is a common idiom when a program wants only its arguments.

Discuss in Forum

40.

What is the output of this C code?

#include <stdio.h>
    int main()
    {
        char *p = NULL;
        char *q = 0;
        if (p)
            printf(" p ");
        else
            printf("nullp");
        if (q)
            printf("q\n");
        else
            printf(" nullq\n");
    }

A.nullp nullq
B.Depends on the compiler
C.x nullq where x can be p or nullp depending on the value of NULL
D.p q

Answer: A

Correct answer: nullp nullq

Both pointers are null. NULL is a null pointer constant, and so is a literal 0 in a pointer context - the compiler converts it, which is why char *q = 0; is legal and gives the same value as = NULL.

A null pointer tests false in a condition, so both if statements take their else branch. Note that the internal representation is not required to be all-zero bits; what the standard guarantees is the conversion from the constant 0 and the comparison, which is all the program relies on.

Discuss in Forum

Loading…

Topics

Subject Categories

Tags: Command Line Arguments Questions and Answers || Command Line Arguments MCQ Questions and Answers || Command Line Arguments GK Questions and Answers || Command Line Arguments GK MCQ Questions || Command Line Arguments Multiple Choice Questions and Answers || Command Line Arguments GK || GK on Command Line Arguments || C Programming Questions and Answers || C Programming MCQ Questions and Answers || C Programming GK Questions and Answers || GK on C Programming

Command Line Arguments Questions and Answers

Topics

Subject Categories

About Us

Stay informed about all important Dates & Notifications