The good thing about C, is that it has been written for programmers who understand the needs, requirements and expectations of fellow programmers. So, it cuts through the shackles of conventional programming languages and gives you, the programmer, more control. The immense success of C can be attributed to the fact that C talks to the computer one-on-one. No wonder then that C is often termed a "hardcore" programming language.

Right, this is the simplest C program that one could have. main() marks the starting point of your program and is absolutely essential. The two {}'s hold the code of your program. Right now, we've not put anything in there, so this program won't really do anything, but let's run it anyway.

Before you can run a C program, you must compile it, turning the human readable source code shown above into machine-readable gobbledygook. Invoke GCC, the GNU C Compiler, from the prompt and pass it the name of the C file, a.c in this instance. The compiler spits out the file a.out (This is the default name of the output file under *nix, for historical reasons).

Type in

#a.out

at the prompt and try it out.

Whoops! Didn't work, did it? You're supposed to add a ./ in front of the file name to tell the shell to pick up the file from the present working directory.

We don't get anything as output; the program simply starts up and exits.

If you wish to give your output file another name instead of the default, pass the -o switch to 'gcc' along with the new name.

Right, that program didn't do much, but this one has (gasp!) one whole line of code in it! printf() is a function. A function is a block of code with a name assigned to it that carries out a certain task. It may or may not accept parameters passed to it containing data. In C, function names are always followed by a pair of ()'s which contain the parameters to be passed, or nothing if no parameters are required.

Here printf() is a function provided by C which prints out the data string passed to it. The string of data is enclosed within a pair of ""'s.

Notice that main() is also followed by a pair of ()'s. Yup, it's a function too, but a special one. It is a function that we define (create) ourselves and it's not provided by anyone. printf() on the other hand comes along with C and all we're doing is calling it here.

You'll pick up this stuff as time goes by, just accept it for now.

Compile the program and gawk at the error message the compiler spits out. Notice the passing resemblance to English and its terse, abusive nature. Fear not, you'll get used to it.

Interpreting error messages takes a little time, but it's not too difficult. Just read the messages slowly and think about it.

a.c: In function `main':

a.c:4: parse error before `}'

First comes the name of the file with the error, 'a.c', then the line number where the error is to be found and then the error itself.

In the first line the compiler tells you that in the file 'a.c', in the function main() we have some errors. The second line then lists the error. Here we're told that on line number 4, there's a 'parse error' before '}'. This means that the compile finds that the syntax of our program is unacceptable and this error occurs before the '}' in line number 4.

Our error is quite simple. All statements in C must end with a ';'. If they don't the compiler spits at you. So let's remedy that in the next program.

Right, in this program, we've put the semi-colon after the function call like we should have and the program compiles properly. Run it and see the string appear on the screen.

Let's clean up the output a bit. '\n' is an escape character and it tells printf() to place a new line after the string. In common parlance, printf() will now 'press' Enter/Return after printing out the string. It looks a little better now.

Intuitively, you might expect this program to print out the two words on separate lines. Unfortunately, C is anything but intuitive and instead of displaying the strings on separate lines, it will display them on the same line.

One has to specify all the details when dealing with C. The compiler isn't clairvoyant and it can't figure out what you want. You have to very explicit in your instructions. The next program shows you the correct way to do it.

By placing two '\n's one after the other, we tell printf() to press Enter/Return twice after "Hi".

Here is one way to print out a number using printf(). The '%d' is a marker that will be replaced by the number 10. Using markers instead of numbers (or strings) directly makes it easier to format strings. They are also invaluable when we start using variables.

Here's how you print out two numbers one after the other. Simple really.

Here's another one of our programs that generates an error from the very beginning. Read it line by line. All it's saying is that the token 'i' is undeclared. More on this in the next program.

Right, here we've declared the variable 'i' to be an int. A variable is a labeled area of memory which we've set aside and which we can refer to as need be. By saying 'i' is an int or integer, we're setting aside 4 bytes of memory for i.

Variables are one of the corner stones of programming languages. The values they hold can be referred to and changed at will. You'll be using a lot of them when you write programs of your own.

A variable is pretty useless unless we use it to hold a value. Here we assign 'i' the value 10 and then print out the value of 'i' in the printf(). What we're actually doing is storing the number 10 in a memory address labeled 'i'. When we wish to access that memory address and print out its value, we use the variable name 'i' to refer to it.

This program isn't too different from program no. 7, but the next program will demonstrate the uses of variables.

Don't let the length of the program put you off. It's really quite simple.

Here we declare a variable 'i' and assign it the value 10. We then print out the value of 'i'. So far so good.

We now give 'i' a new value to hold. The value of 'i' will now be 20. The earlier value of 10 is discarded and lost. The new value is then printed.

i=i+5;

This is why variables are such a good idea. Always look at the right side of the equal to sign first. Here we're adding 5 to the present value of 'i' (which is 20 right now) which gives us 20+5; 25. We now print out the value of 'i' which is now equal to 25.

In a similar manner we add 1 to the current value of 'i', printing out 26.

i++ is just shortcut for i=i+1. This is a very common way to increment the value of a variable by 1.

Similarly, i+=1 is the same as saying i=i+1. Rather than repeat the name of the variable twice in the same line, we shorten it thus. In the same way, i-=1 is the same as i=i-1, i*=1 is the same as i=i*1 etc.

Not too difficult was it?

Earlier in the text we'd mentioned that when we declare 'i' to be an int, the compiler reserves 4 bytes in memory for us. An int is not the only type of datatype there is. A char is 1 byte large, a long is 4 bytes long, a float (for floating point numbers) is 4 bytes large as well while a double is 8 bytes large. The larger the variable, the larger is the value it can hold. char, with only 1 byte to its name can hold a maximum value of 255, while an int can hold up to 4billion

This program uses the C language keyword sizeof() in conjunction with the function printf() to display the sizes of the various datatyped variables.

One word of caution. The size of datatypes is not fixed, only their relation to each other is. You can be sure that a long will be larger than or equal to a char on every implementation of C, but you can't be sure that it will be 4 bytes large. In fact, on 16 bit systems (like MS-DOS), an int is 2 bytes large, not 4. That's why sizeof() has been provided so that you can check the size of variables to produce truly portable code.

Here we'll quickly run through a list of C operators. Operators are symbols that er.. operate on numbers and return either 0 (for false) or 1 (for true).

In the first instance we check to see if 4 is greater than (>) 2. Since it is, the operator returns a '1'(for true) which is then displayed by printf().

Similarly, we check other situations, like is 2 smaller than (<) 4. It is.

Is 2 greater than (>) 4? No it's not.

Is 2 greater than or equal to (>=) 2? Yes, 2 may not be greater than 2, but it is equal to it.

Is 2 greater than (>) 2? No it's not.

Is 2 not equal to (!=) 3? Yes, 2 is not the same as 3.

Is 2 not equal to (!=) 2? 2 is equal to 2, so the statement is false.

The exclamation mark (!) is used to invert the value of a variable. If it's 0, it will become 1 and if it's 1 it will become 0. Here 0, when inverted, will become 1.

Any non-zero value, when inverted, becomes 0. So !4 is equal to 0.

The same applies to negative values as well.

First compile and run this program.

Instead of seeing a "Hi" as you expected, you get nothing. You end up back on the prompt.

if() is a C keyword and it's used to control the flow of the program. Computer programs often have to make decisions based on information they receive. Statements like if() are used to evaluate variables and perform actions depending on the result.

Here we've said 'if(0)'. Under C and most other computer languages, '0' means FALSE. Read like English, the statement is "If the condition is TRUE (any non-zero number), then execute the next statement. If it's FALSE, skip it".

The next few programs should clear up any doubts you have.

Here we have 'if(2)' where if() is asked to evaluate a non-zero number. That's always TRUE, so the next statement is executed and the string "Hi" is printed on the screen.

Here we prove once more that anything that's non-zero is TRUE.

Now this is interesting. According to all that we've told you so far, neither of the printf()'s should be called, yet only the first one is ignored. This is because if() only affects the statement after it and no other. So the second printf() is unaffected and does it's job.

Of course, if you want the if() to control more lines of code, all you need to do is use the handy {}'s to group them together. Now both printf()'s will be ignored.

Here we introduce another keyword, else. Notice that else has no ()'s after it and it does no evaluation. Its use is simple. If the if() evaluates to FALSE, then you might want some other lines of code to be executed. Simply place them after an else (grouped together between a pair of {}'s if you have more than one statement). You would read this statement as "if TRUE, print 'Hi', else, print 'Bye'".

More fun with if(). In this program we have a variable i, (an int) which we assign the value 6. In the first if(), we're actually saying if(6) (which is a non-zero number and therefor always TRUE) and so the first printf() is called. After that we check to see if 'i' is greater than or equal to (>=)5. Since the value of 'i' is currently 6, which is greater than 5, the if() evaluates to TRUE and the second printf() is printed as well. Check the output and confirm that if you wish.

Here we try out the same program with different values of 'i'. Both statements evaluate to FALSE and therefor neither of the printf()'s are called.

This program introduces another C keyword, for(). for() is used to create loops, or chunks of code which will be repeated a set number of times or until a condition is met.

The syntax is simple.

for(i=0;i<=10;i++)

In the space between the opening bracket and the first semicolon, we initialize the variable 'i' to 0. This is done only on the first pass through the loop. In the space between the first and second semicolons, we set the condition that must be meet for the loop to continue. In this case, 'i' must remain smaller than or equal to 10 for the loop to work. Finally, we say that at every iteration of the loop, the variable 'i' must be incremented by 1. Examine this closely and you'll see this loop should run from 0 to 10, which it does.

The for() only affects the statement after it (unless you group a whole bunch of them together using {}'s). It is the second printf() which prints the 11. Why 11 instead of 10? That's simple enough. When 'i' is 10, the for() statement will check to see if it's smaller than or equal to 10 (which it will is) and then increment the value to 11 (i++). The printf() will be called and 10 printed out onto the screen. Now we go up to the for() statement again. 'i' will once more be tested against 10. This time it's 11 and therefor larger than 10. The condition is no longer TRUE and the loop will exit. When it does, the program will carry on downwards and the second printf() will be executed. The current the value of 'i' will then be 11, which is what is printed out.

Here we add a pair of {}'s to include both printf()'s into the loop. Now both printf()'s will be called through each iteration, giving us the same output twice.

This is a common type programming error. Infinite loops. This program will loop the loop till you CNTL+C it, shutdown the computer or hell freezes over. The mistake is simple, at no point do we increment 'i'. Since the value of 'i' never increases, i<=10 is always TRUE.

Here while() is a C keyword. It does exactly what for() does, handle looping. Which one you use is entirely up to you.

This is a working example of a while() loop. Notice that it contains all the elements of a for() loop, just in different places. 'i' is initialized before the while() (If you initialize it inside the loop, every iteration will set the value back to 0, and you'll have another infinite loop on your hands). The condition is checked by while() itself and the value of 'i' is incremented by the statement 'i++' within the loop. Take care to ensure that the incrementing of the counter takes place within the loop, or you'll have another infinite loop to deal with.

This is a nice example of for() and if() being used together. We first set up a for() loop which will loop 11 times from 0 to 10 (it's 11 times because we count the starting 0 as well). But we only want to print out the numbers from 3 onwards. All we need to do is add an if() before the printf() and check the value of 'i' before we print.

Another way to do this would have been to initialize the variable 'i' to 3 in the first place and remove the if().

Here we go into greater depth with the if() statement. '&&' means AND and the usage is straightforward. If 'i' is greater than or equal to 3 AND if 'i' is greater than or equal to 6, print 'i'. So we get the output, 3 4 5 6.

Similarly '||' stands for OR and the usage is the same. Only print out the value of 'i' if 'i' is smaller than or equal to 3 OR if 'i' is greater than or equal to 6.

Here's a simple program to help you differentiate between the assignment operator '=' and the comparison operator '=='.

Here we assign 'i' the value 6. The first printf() prints 0 because the expression i==7 evaluates to 0. Since the value of 'i' is unchanged, the second printf() prints out 6. Next we change the value of 'i' by saying i=7 and printing out that value.

Here we have an example of using the assignment operator instead of the comparison one. It should be 'if(i==3)' and since it isn't and 'i' is repetitively assigned the value 3 (which is less than 10), we enter an infinite loop.

This is the correct way to do it.

In this program, we play around with printf() a bit. printf() is actually a very powerful function and can output data in various formats.

In this program, we print out a whole bunch of characters.

This cute little program prints out all the ASCII characters. Your first useful program!

Here we show you how to use the operator. When we say i='A', the value of 'A' under the ASCII standard is stored in 'i'. Just another way to print out all those funky ASCII characters...

This is getting real good, real fast.

Right! Enough of that ASCII stuff.

This program gives us some interesting results. Initially 'i' is equal to 6.

In the first printf() we have i=7!=8

Whenever C finds 2 operators in the same line, it stops and ponders. It then processes the statement according to the rules of operator precedence. Just because the equal to (=) comes first in the statement, it doesn't mean it will be executed first. According to this rule whenever C sees a not equal to (!=) and a equal to (=) in the same line, it executes the != part of the statement first. (the rest of the rules of operator precedence will be covered later). So the above statement is broken as :

7!=8

which is true hence the value returned is 1. Then we have

i=1

Thus the first printf displays 1 and ditto for the second printf.

In the first printf(), (i=7) evaluates to 7 since we're assigning 'i' a value of 7 and we succeed in doing that. 7 is not equal to 8; this statement is self-evident and true, so the result is 1. The second printf() simply prints out the value of 'i'.

More of the same. 'i' is 7 which is equal to 7, so the statement 7!=7 is false. A 0 is returned and printed out, along with the current value of 'i'.

Here we introduce a new concept, functions. A function is a block of code that can be passed information in the form of parameters and which performs some task.

Take the example here. We define a function can abc() and place a single call to printf() in it. The function is defined outside the scope of the function main() (Yes, even main is a function, so is printf() for that matter). In main(), we call the function abc() twice in this manner.

Since abc() is called twice, the code in it will be executed twice, and so we see two instances of the string "In abc" on the screen when we run the program.

As I mentioned earlier, functions can be passed information in the form of parameters and this is how it's done.

abc() is defined as a function which accepts two ints, 'i' and 'j'. The value of these variables is then printed out.

In main(), we call abc() with two parameters, 10 and 20 in this manner.

abc(10,20);

The value of 10 will end up in 'i' and 20 in 'j'. These values are then printed out.

More of the same. Instead of passing the values directly, we first place them in variables and pass those instead. In the next call to abc(), we play with the values before we pass them. The changes are reflected in the output.

Up until now, we've been passing information to functions, lets see if functions can talk back to us and give us some data in return as well. By writing

i=pqr()

we're telling the compiler to place the return value of pqr() in the variable 'i'. Since pqr() is presently empty, we get some random value in return. Time to remedy that.

The keyword return solves our problem. Now 'i' will contain the value 100.

Time to roll up out sleeves and enter the big bad world of pointers. This is a new class of variable which points to places in memory which contain useful data.

In this program we show that now matter what you declare a pointer to be, whether char, int or long, it's size will always be 4 bytes (at least on 32 bit Intel machines).

However, the data type the pointer is declared to be does affect its behavior. Here we first point the pointers to the first location in memory. We then increment the pointers by one and print out their location (%x helps with that). When incremented, int and long pointers leap ahead in 4 byte large bounds. A char pointer on the other hand ambles along, increasing by one byte every time.

Here we show you the address of the variable i. 0xbffffa24 is the location in memory where the value of 'i' is stored.

Here we demonstrate another datatype, short, which is 2 bytes large. Notice the way a short pointer increases in 2 byte large increments.

This is a really important program. Take it slow and easy.

We first declare two variables, 'i', a short and 'p', a pointer to a char. We then print out the location of the variable 'i' in memory. We then assign 'i' the value 300 and print it out.

We then print out the memory location 'p'. After that, we point 'p' to the same address as 'i' and print out the new memory location of 'p'. Notice that 'p' now points to the same memory location as 'i'.

When we store a number in memory which is larger than 255 (the maximum value that a single byte can hold), it has to be broken up into segments and stored in several bytes.

Let's take a number like 300. Now 300 is larger than 255, so it has to be split up over atleast 2 bytes. This obviously means that the number must be split up into two segments and weighted so that we can extract the correct value later.

We're now going to be dealing with another important aspect of C, the stack. This is an area of memory which is used primarily for passing parameters and the like and is pointed to by a stack pointer.

Take the program shown above. All we're doing is passing the parameters to the function and then displaying them using printf().

When the function abc() is called with two parameters, C does a lot of work internally. First, it goes to the memory location of 'i' and picks up the value stored there. It then goes to the memory location of 'j' and picks up the value it find there. It then places these values on the stack.

Let's assume that the stack pointer currently points to the memory location 104. C will go and place the value of the variable in 'j' (515) at that location and move the stack pointer 4 bytes downwards to 100.

C will next place the value of the variable 'i' (300) in the bytes following 100 and move the stack pointer 4 bytes down to 96. The function abc() will then be called.

When abc() comes onto the scene, it doesn't know much, but it does know that it needs two variables. It checks the stack pointer and follows it to the location of the stack. It then pops off the first 4 bytes from 96 to 100 and places the value found in them (300) in the variable 'x', which is 'i's counterpart. Since, abc() wants two parameters, it pops off the next 4 bytes (515) and places them in 'y', 'j's counterpart. The stack pointer is still set to 96, that has not changed.

abc() then prints out the variables and returns.

Once main() regains control, it sets the stack pointer back to 104. main() remembers the number of parameters passed and so it takes on the responsibility for setting and resetting the stack pointer. abc() simply uses the data on the stack.

And that's all there is to it. The stack is a dumping ground for parameters and variables, making the task of passing things around much easier. Notice one quirk though, 'j' is passed into the stack before 'i' and then 'i' is popped back in before 'j'. In the end, the values are in the same position.

This is an interesting one. Here we're passing two chars to abc() and referring to them as ints within abc() (by default, all variables returned or passed are ints). This should lead to some confusion with both chars being incorporated into the very first int and the second int containing gibberish.

But the output is absolutely fine, so what happened?

The answer is simple. The stack pointer always moves in 4 byte increments. Whether it's a char, short, int or long, a variable always occupies 4 bytes on the stack.

Thus the program works.

Unfortunately, the converse is not true. Here we try to read in ints stored on the stack into abc() as chars. Since we're only taking in the very first bytes of the variables, we get 44 and 3.

Lets probe further.

Whoopse! Here we don't give abc() any parameters but still pop two of them off the stack. When abc() is called, it is unaware that no parameters have been placed on the stack. So it goes the stack and pops of two 4 byte chunks and places the values found in them in 'x' and 'y'. Naturally, these values are totally random and so are the results.

Thankfully, since ??? main()??? will be doing the cleaning up and the stack pointer is not changed by abc(), the rest of the program is not affected by this mismatch.

Here's another interesting program. We're passing two values through the stack, but not picking them up. That's fine because once more, since ???main()??? is doing the cleanup, whether we use the stack or not is immaterial.

Let's talk about this stack business a little more.

Notice the output. The numbers are the same.

main() is a function like any other and it too is passed parameters. The argc is an int and it contains the number of command line parameters passed to the program at startup. Currently the result is 1 even without any parameters being passed. This is because the program name itself is counted as well.

Where does the number come from? the stack of course! And who puts it there? The operating system.

The program shown above works in exactly the same way as the previous one. The variable 'argc' is not special in anyway. Instead like a lot of things, it's the name traditionally give to this variable.

Here we create an array and then print out the size of the array. An array is a continuous stretch in memory used to store information. It's just like a rather large (where the size is defined at compile time) variable.

In this program, we create an array of chars which is three units long. The size is three bytes because the array is made up of three bytes (chars).

Here we create an array of pointers to chars, three units long. The size this time is 12 because we're storing pointers to chars here, not chars themselves. Pointers are always 4 bytes long; no compromise there.

We've already shown you one parameter passed to main(), here's another. argv is an array of pointers to chars which stores the actual parameters passed to the program by the user (through the OS). You could see the number of parameters passed using argc, now see the actual parameters themselves.

The array argv[] contains pointers to strings which hold the actual text of the parameters passed. In the example shown above, argv[0] would contain (let's assume) 100 and argv[1], 104. If we were to go the memory location 100, we'd see the string "./a" and at 104 we'd find "ab". In the printf(), we use '%s'. When using '%s' we pass printf() the address of the string to be displayed. argv[0] contains 100, the address of the first string and argv[1] contains the second string. In this way, using an array of pointers we can easily access these strings.

Here's the proper way to do it... This will work for an arbitrary number of parameters.

Here's a great little program that actually does something useful. Think of it as a slimmed down 'cat' program. You pass it the name of a text file and it prints it out onto the screen.

We'll step through this program one line at a time.

This is a preprocessor directive. It tells the compiler to add in all the lines from the file stdio.h. This file contains function definitions, global variables, and other odds and ends.

We're familiar with this atleast.

Here we create a pointer to a FILE. FILE isn't an inbuilt C datatype, rather, it's a structure tag defined in stdio.h.

Here we create a variable i.

We now call a function fopen() to open up the file passed as the first parameter (argv[1]) for reading ("r"). fp now contains a pointer to a structure which looks like FILE and is called a handle. Handles are variables which themselves contain no useful information. Rather they point to useful data. Since fp points to a structure that contains all the information about the file that we're supposed to read, all further references to that file can be through fp. Other functions can examine fp and get all the information they need to process the file.

while ((i=fgetc(fp))!=-1)

Things get more interesting in the while() loop. Examine the innermost parenthesizes first.

This is a function that retrieves a character from a file. Notice that we don't pass it the file name, but instead we give it the file handle. fgetc() will retrieve the file name and other bits of information from the structure that fp points to. The character returned by fgetc() is stored in 'i'.

C processes statements from the inner parenthesis inwards. The statement will no look like this.

So the while() will check if the character read in is -1. If it isn't, we proceed onwards and print out the character and if it is, we pop out of the loop.

In this manner we print out the entire file.

This is the same program, slightly modified to read in and print out multiple files one after the other. The changes are pretty straightforward.

Whenever C sees a pair of matching ""'s it stores the string within them at a memory location. In this case strcmp() (string compare) will look like this internally.

strcmp(<addr of the first string>,<addr of the second string>);

strcmp() goes to the addresses specified and checks to see if the strings are identical. If they are, it returns zero, if not, a non-zero value is returned.

Here p is a pointer to a char (char *p) and we point it to the address location of "ABC". Remember that all matching ""'s are replaced with the location of the string in memory. so

strcmp(p,"ABC");

is the same as

strcmp(<addr of the first string>,<addr of the second string>);

or

strcmp("ABC","ABC");

Clueless lamers may decide to play around with your program, renaming 'rm' to 'cp'. To prevent this, you can add in some code to prevent any name changes to the program. Of course, if they have the source, you're out of luck!

This program checks to see if argv[0] (which is the program name) is the same as "\a" If it is, all is well and we print out "Hi", if not, we print "Bye". You would of course add more appropriate code.

Just a small factoid and a demonstration of it. The escape character \b stands for backspace. So "A" is deleted even before it can be printed.

Here's a cute one. Call it recursion or general craziness. You'll get an endless string of "confusion" as main() is called over and over again from within itself. Endless hours of enjoyment!!

A function is just a block of code and a function name is a label that points to that block of code. Since functions are stored in memory, they too have a starting addresses. The function name points to the start of the function code in memory. So by referring to the function without the ()'s we're asking for it's starting address and not running it. Here we print out the memory location where the function abc() starts.

No this won't work for obvious reasons. As the error message states, abc() is undeclared. You can't refer to a function that doesn't exist.

Thought you'd got the compiler licked huh? The error message didn't go away when you defined the function, instead two more lines were added to it!

C insists that functions be declared before they are used. One must state the name, return value and parameter datatypes right at the start even before main(). This is called declaring a function and the declaration itself is called a function prototype. When we actually sit down and create the function later on and add code to it, we're defining it.

In this program we've defined the function, but not declared it. To rectify this add the line

int abc();

at the top or do this.

If we define the function itself before main(), we don't need to declare it.

Here we declare the function using a function prototype and define it later.

The reason function prototypes are important is because they allow the compiler to perform type checking when it's compiling your code. In other words, they let the compiler catch you if you try to pass four pointers to a function that accepts 2 chars. Error checks become more accurate and that can save your bacon.

Strange declaration! What is it exactly? It's got an asterix, so it's a pointer, but to what?

Simply put, p is a pointer to a function that accepts no parameters and returns an int. The format looks a little like this.

<return value> (*<name of pointer>) (<parameters, if any>)

The size of p is four, so it is a pointer.

Here's more on pointers to functions and how to use them. In this program, p is a pointer to a function that takes no parameters and returns an int. By saying

p=abc;

we point p to the starting address of abc(). Printing out their address, we see they both point to the same location. Saying p() will execute the function abc() because p points to it.

Think of it this way, the label abc points to the start of the function code, (let's assume it starts at 500). When you say

abc();

to call the function, you're actually writing

500();

The compiler will go to location 500 in memory and start executing the code from there.

So when we point p to the start of abc() (which is at 500), and we say

p();

We're giving the compiler absolutely the same information. The compiler sees no difference between the two calls.

Later we point p to the start of pqr() and print out the addresses again.

This is a simple program that opens a file in a read/binary mode. Binary takes care of non-printable characters too unlike ASCII/text files.

This program demonstrates a useful function in C named atoi(). It converts strings to actual numbers. In this example, we give the string "123" as a command line argument to './a'. "123" is stored as a string and not a number, so you can't add it to something or subtract from it or anything. It is a string of ASCII characters, not the numbers themselves. If you we're to view their values in memory, you'd see 49,50, and 51, the ASCII values of the characters 1,2, and 3. To convert them into actual numbers that you can manipulate you use atoi(). You just give it the string and grab the int it returns. Here we're just printing them out.

Remember, they may look the same, but they're very different.

Create a file named z.txt with the string ABCDEFGHIJK (end with an Enter/return (\n)) contained within.

This is a program which will demonstrate the functionality of fseek(), a function which moves the file pointer around.

We first open up the file and retrieve a single character from it, which we display.

We then call fseek() for the first time. The first parameter we pass it is the file handle fp. The second parameter tells fseek() to move the file pointer by four characters (A,B,C, the pointer moved ahead by three, is now at D) and the third parameter is 0, which tells fseek() to move the file pointer onwards from the start of the file.

Now what exactly is the file pointer? It's not a very complicated concept. The file pointer is a pointer (invisible to us) which points at the character to be read in from the file. So when we say fgetc() and read in a character, the file pointer is moved one ahead, so that the next time we say fgetc(), we read in the next character and not the same one again. We use fseek() to manipulate this pointer.

Keep in mind that everytime we call fgetc(), the current character is printed out and the file pointer is moved ahead by one automatically.

So anyhow, we read in the fourth character from the start of the file, which is D and print it out.

We then move to the eighth character from the start of the file (H) and print it out. Right after that, we say

fseek(fp,0,0);

Which moves the file pointer back to the start of the file. You don't have to reset the pointer like this, we're just showing you how to do it.

fseek(fp,4,1);

Here the second parameter is 4 and the third one is 1 which tells fseek() to move ahead by five characters from its present position. So we get E.

fseek(fp,3,1);

Similarly, here we move four positions ahead from our current location and print out I.

A minus sign means we move backwards from the (1) current position to F.

fseek(fp,0,1);

This is a pretty simple. Here we're telling fseek() not to move the pointer anywhere, and the next fgetc() prints out G. Remember, the previous fgetc() had printed out F and moved the file pointer ahead by one.

fseek(fp,-2,2);

This tells fseek to go to the end of the file (2, the third parameter) and seek backwards (-2, the second parameter) to the third last character, which is K. Keep in mind that final \n (the Enter/Return) takes up two characters.>

This program manipulates any file and adds the character specified at the command prompt at the position specified. Here, we take in three command line arguments, convert the first two into integers and open up the last one. We then go to the position specified in the file and place the character specified there.

Here we replace B with A.

Here we read in the characters in the file z.txt and display the ASCII values on the screen along with the final byte count. Notice that it's 8 rather than 5. This is because the \n (Enter/Return) though not displayed, still takes up space in the file. The 10 stands for Line Feed. A single line feed marks the spot where you pressed Enter/Return. ??Two together???

In this program, we open up a file 'z.txt' for reading. We then use a for() loop to initialize every member of the array a[] to Z. We then print out the members of the array using another loop.

fread(a,8,1,fp);

We then use fread() to read in 8 units (second parameter) of size 1 (third parameter) into the array 'a' (first parameter) from the file pointed to by file handle fp (fourth parameter). We then print out the new values in a[]. Right at the end we read in one value and print it out.

Notice that we use 'a' to refer to the start of the memory address for the array 'a[]'.

Notice that only the first eight members of a[] have new values, the ones we haven't touched as still set to Z.

Notice also that we haven't bothered with {} around the for() loops. This is because they are needed only if there is more than one statement to use in the loop. Here we've got just one statement, so the {}'s would have been redundant.

Here's a quick and dirty introduction to structures. Structures are convenient ways of grouping related bits of data. They just make life a lot simpler and they're not difficult to understand.

Here in main, we create a structure zzz using the struct keyword. It contains an int, a char and a long.

We then print out the sizeof() zzz which is the sum of the size of all the datatypes within it i.e. int + char + long or 4 bytes + 1 byte + 4 bytes = 9 bytes.

We then print out the starting address of zzz, and the members within it. Notice that the first member 'i' is to be found at the same location as the start of the structure and the rest follow at 4 byte intervals.

Notice also how we refer to the members within zzz. If we wish to access 'i' we say 'zzz.i'. For 'j' we say 'zzz.j' and so on.

In the last few lines of the program, we assign 'zzz.i' a value, increment it and then print it out. Nothing to it really.

Linked list

Here we introduce you to a new but very important function, malloc(). malloc() or memory allocation allocates a certain block of memory for you at run time. This is different from using arrays because their size is hard coded in. However, malloc() can be used at any time to return pointers to vast sections of memory for you to use.

Here we use 'p', a pointer to a char to hold the return value of malloc() which returns. We first use malloc() to allocate a block in memory 100 bytes large, print out it's starting location and then overwrite 'p' with the starting location of another block 10 bytes large.

Here we call the function abc() from within main() six times by using a loop. 'i' is a global function so it can be accessed by every function in the source file and it's value is not lost when the function ends. Global functions are automatically initialized to 1 by C. In abc() we check the value of 'i'. If it's 1, we're being called for the first time and we print out the value of i with two dots. We then increment the value of 'i' to ensure that the if() statement is never true again.

The next time abc() is called, the if() will return false and the else will be executed. The value of 'i' is not lost, so 2 is printed 5 times.

Here's a simple program that loops 11 times (remember, we count from 0) and prints out the value of 'i' each time.

Here, when 'i' becomes equal to 3, we enter the if() statement. The keyword break, breaks out of the loop and we end up at the final braces. The program ends.

Here we use gets() to read in a string from the user and we store it in the array 'a[]'. We then print it out. Ideally, we should be using malloc() but what the hell!

Here we demonstrate that arrays when created are uninitialized. The first printf() outputs gibberish. We then strcpy() (string copy) "ABC" into 'a[]' and that's what we print out next.

Here's some more on structures.

We create a structure tag zzz. This is different from a structure because it a new datatype by itself. One can create variables to it and pointers to it too.

In main() we do just that by typing

struct zzz a;

struct zzz b;

struct zzz *c;

To create two variables that look like 'zzz' and one pointer to a struct 'zzz'.

We initialize the members of 'a' to some values and print out the memory location where they are stored along with the values themselves. We then do the same for 'b'.

After that, we print out the size of 'c' which since it is a pointer, will always be 4.

We then point 'c' to the start of 'a' and print out its location. It's the same as 'a''s. Now to access the members of 'a' through 'c' we can't use '.', instead we use '->'. So

printf("%d\n",c->i);

will print out the value of 'a.i'

c->j=3;

and this will change the value of 'a.i' to 3. We play around with 'b' in a similiar manner.

Here we create a structure tag zzz and place a pointer to itself within it. This is a very useful thing we can do in structures. We create 'a' which looks like 'zzz' and then print out its size which is 100 chars + 1 pointer = 104 bytes.

Type this in and gawk at the pretty errors.

Quite obviously, we can't use GUJJU until we tell the compiler what it is. Here we use a preprocessor directive to set GUJJU to 420. What this tells the compiler to do is replace every instance of the word GUJJU with the number 420. This is called a MACRO and by convention they're always in uppercase.

Here we demonstrate the functioning of sprintf(). This function works just like printf() but unlike printf(), it outputs the formatted string to a location in memory instead of to the screen.

So we place the contents of the string into the array 'a[]' and then print out the array.

Here is another nifty function, fprintf() which prints to a file handle instead of to the screen. Very useful when you want to write formatted strings to disk.