C programming notes - School of Physics

C programming notes
file:///F:/my_docs/web_phys2020/Cprogrammingnotes.html
35 of 40 19/03/2007 10:06 AM
/* defines the symbol DEBUG */
#ifdef DEBUG
/* code here is compiled if DEBUG is defined */
#elif defined UNIX
/* code here is compiled if DEBUG is not defined, and UNIX is defined */
#else
/* code here is compiled if neither DEBUG or UNIX are defined */
#endif
#if 0
/* code here is never compiled */
#endif
Command-line arguments, and returning a status to the shell
Up until now, our "main" function has always been declared as "int main(void)". We have seen that the integer return
value is available to the UNIX "shell" in the "$?" environment variable, and this can be used to alter the execution of
scripts. It turns out that "main" can actually take arguments, and these are traditionally given as "int argc, char *argv[]",
where argc is one plus the number of command-line arguments provided to the program, and argv is an array of
character strings containing the arguments. argv[0] is usually the name of the program itself. An example
(statusexample.c) will hopefully clarify this:
#include
int main(int argc, char *argv[]) {
printf("this program is called '%s'\n", argv[0]);
if (argc == 1) {
printf("it was called without any arguments\n");
} else {
int i;
printf("it was called with %d arguments\n", argc - 1);
for (i = 1; i < argc; i++) {
printf("argument number %d was \n", i, argv[i]);
}
}
exit(argc);
}
echo $?
Allocating memory at run-time - malloc
The situation often arises that you don't know the size of a data structure in your program at compile-time. For
example, suppose you are writing a program to read an 2D image from a file into the computer's memory. If the size of
the image can vary at run-time, it would be nice not to have to pre-define the size of the memory array in your program.
C allows you to do this through the concept of allocating and deallocating memory.
Allocating memory means requesting the computer to give you access to a contiguous block of memory. E.g., suppose
you need a megabyte; you ask the computer "can I use a megabyte of memory, and if so, can you please tell me where
the memory is?". You ask the question by calling the function "malloc", which takes a single argument: the number of
bytes of memory that you want. malloc will attempt to allocate the memory, and if it is successful it will return a
pointer to the first byte of the memory block (if malloc was unsuccessful, it returns NULL; this is a rare enough
occurence for reasonable memory requests that you should handle it with "assert").
Deallocating memory means telling the computer "I have now finished using this block of memory that you previously
allocated for me with malloc, so you can now have the memory back again for some other purpose". You deallocate
memory by calling the "free" function.
Some important points to remember when using malloc:
malloc returns a pointer to void, i.e., "(void *)", which just means that malloc itself knows nothing about what
the block of memory is to be used for, which is fair enough since you didn't tell it. However, you do have to let
the C compiler know, and you do this by type-casting malloc's result (see the example below).
You should always call "free" to deallocate any memory that you have finished with. Note carefully that the
argument to "free" must be a pointer obtained from malloc, and that you can only call free once for a given block