Passing arguments to a program

Passing arguments to a program

We can't modify the behavior of our hello program with arguments. We have no way to pass it another character string for instance, that it should use instead of the hard-wired "hello\n". We can't even tell it to stop putting a trailing new line character.

Programs normally receive arguments from their environment. A very old but still quite effective method is to pass a command line to the program, i.e. a series of character strings that the program can use.

Let's see how arguments are passed to a program.

#include <stdio.h> (1)

int main(int argc,char *argv[]) (2)

(6)

return 0;

We include again stdio.h

We use a longer definition of the "main" function as before. This one is as standard as the previous one, but allows us to pass parameters to the program. There are two arguments:

int argc. This is an integer that in C is known as "int". It contains the number of arguments passed to the program plus one.

char *argv[] This is an array of pointers to characters containing the actual arguments given. For example, if we call our program from the command line with the arguments "foo" and "bar", the argv[ ] array will contain:

argv[0] The name of the program that is running.

argv[1] The first argument, i.e. "foo".

argv[2] The second argument, i.e. "bar".

We use a memory location for an integer variable that will hold the current argument to be printed. This is a local variable, i.e. a variable that can only be used within the enclosing scope, in this case, the scope of the function "main".

We use the "for" construct, i.e. an iteration. The "for" statement has the following structure:

Initialization. Things to be done before the loop starts. In this example, we set the counter to zero. We do this using the assign statement of C: the "=" sign. The general form of this statement is

variable "=" value

Test. Things to be tested at each iteration, to determine when the loop will end. In this case we test if the count is still smaller than the number of arguments passed to the program, the integer argc.

Increment. Things to be updated at each iteration. In this case we add 1 to the counter with the post-increment instruction: counter++. This is just a shorthand for writing counter = counter + 1.

Note that we start at zero, and we stop when the counter is equal to the upper value of the loop. Remember that in C, array indexes for an array of size n elements always start at zero and run until n-1.

We use again printf to print something in the screen. This time, we pass to printf the following arguments:

"Argument %d = '%s'\n"

count

argv[count]

Printf will scan its first argument. It distinguishes directives (introduced with a per-cent sign %), from normal text that is outputted without any modification. We have in the character string passed two directives a %d and a %s.

The first one, a %d means that printf will introduce at this position, the character representation of a number that should also be passed as an argument. Since the next argument after the string is the integer "count", its value will be displayed at this point.

The second one, a %s means that a character string should be introduced at this point. Since the next argument is argv[count], the character string at the position "count" in the argv[ ] array will be passed to printf that will display it at this point.

We finish the scope of the for statement with a closing brace. This means, the iteration definition ends here.

Now we are ready to run this program. Suppose that we have entered the text of the program in the file "args.c". We do the following:

h:\lcc\projects\args> lcc args.c

h:\lcc\projects\args> lcclnk args.obj

We first compile the text file to an object file using the lcc compiler. Then, we link the resulting object file to obtain an executable using the linker lcclnk. Now, we can invoke the program just by typing its name:

h:\lcc\projects\args> args

Argument 0 = args

We have given no arguments, so only argv[0] is displayed, the name of the program, in this case "args". Note that if we write:

h:\lcc\projects\args> args.exe

Argument 0 = args.exe

We can even write:

h:\lcc\projects\args> h:\lcc\projects\args.exe

Argument 0 = h:\lcc\projects\args.exe

But that wasn't the objective of the program. More interesting is to write:

h:\lcc\projects\args> args foo bar zzz

Argument 0 = args

Argument 1 = foo

Argument 2 = bar

Argument 3 = zzz

The program receives 3 arguments, so argc will have a value of 4. Since our variable count will run from 0 to argc-1, we will display 4 arguments: the zeroth, the first, the second, etc.

Iteration constructs

We introduced informally the "for" construct above, but a more general introduction to loops is necessary to understand the code that will follow.

There are three iteration constructs in C: "for", "do", and "while".

The "for" construct has

an initialization part, i.e. code that will be always executed before the loop begins,

a test part, i.e. code that will be executed at the start of each iteration to determine if the loop has reached the end or not, and

an increment part, i.e. code that will be executed at the end of each iteration. Normally, the loop counters are incremented (or decremented) here.

The general form is then:

for(init ; test ; increment)

The "while" construct is much more simple. It consists of a single test that determines if the loop body should be executed or not. There is no initialization part, nor increment part.

The general form is:

while (test)

Any "for" loop can be transformed into a "while" loop by just doing:

init

while (test)

The "do" construct is a kind of inverted while. The body of the loop will always be executed at least once. At the end of each iteration the test is performed. The general form is:

do while (test);

Using the "break" keyword can stop any loop. This keyword provokes an exit of the block of the loop and execution continues right afterwards.

The "continue" keyword can be used within any loop construct to provoke a jump to the end of the statement block. The loop continues normally, only the statements between the continue keyword and the end of the loop are ignored.

Basic types

The C language has the following types built in:

These are the basic types of lcc-win32. Other types for numbers exist, for example the "bignums", with infinite precision, or the complex numbers. To use them you should include the corresponding header file, they are not "built in" into the compiler.

Summary.

Functions receive arguments and return a result in the general case. The type of the result is declared before its name in a function declaration or definition.

The "main" function can receive arguments from its calling environment.

We have to declare the type of each identifier to the compiler before we can use it.