C programming notes - School of Physics

C programming notes
file:///F:/my_docs/web_phys2020/Cprogrammingnotes.html
30 of 40 19/03/2007 10:06 AM
}
By using the GNU debugger, gdb, we can identify the actual memory locations that the C compiler uses to store the
variable in the above program. It is then possible to draw up a table (see below) showing the detailed operation of the
program. You should follow this example very carefully so that you understand what is going on.
Variable Starting Value after the specified line has executed
location 7 8 9 10 11 12 13 14
------------------------------------------------------------------
m 0xbffff98c 0 0 1 1 1 1 1 1
n 0xbffff988 1 1 1 1 1 1 1 1
k 0xbffff984 2 2 2 1 1 1 1 1
p 0xbffff980 ? 98c 98c 98c 98c 98c 98c 98c
msg 0xbffff970 hello hello hello hello hello Hello Hello HellO
cp 0xbffff96c ? ? ? ? 970 970 976 976
The memory addresses are shown in hexadecimal, and only the rightmost three digits are shown (e.g., 98c) for
convenience in displaying the table. Memory addresses are always given in units of bytes. The above table shows, for
example, that the variable "m" occupies the memory addresses 0xbffff98c, 0xbffff98d, 0xbffff98e, and 0xbffff98f. You
will note that 16 bytes are reserved for "msg", even though "msg" only needs 6 bytes (5 for the characters in "hello"
and one for the trailing null byte). The C compiler won't guarantee any particular placement in memory, and may leave
gaps, particularly to align numbers with 4-byte boundaries (i.e., so that their memory addresses are divisable by 4).
Note the very important point that the name of an array ("msg" in the above example), if used without an index, is
considered to be a pointer to the first element of the array. In fact, an array name followed by an index is exactly
equivalent to a pointer followed by an offset. For example (pointerexample2.c),
#include
int main(void) {
char msg[] = "hello world";
char *cp;
cp = msg;
cp[0] = 'H';
*(msg+6) = 'W';
}
printf("%s\n", msg);
printf("%s\n", &msg[0]);
printf("%s\n", cp);
printf("%s\n", &cp[0]);
return 0;
Note, however, that "cp" is a variable, and can be changed, whereas "msg" is a constant, and is not an lvalue (i.e., it can
not be used on the left of an equals sign).
Pointer arithmetic
You can add and subtract numbers to/from pointers, but the results may surprise you. For example, if "p" is a pointer to
an "int" (i.e., "int *p"), then "p++" actually adds 4 to "p"! The logic behind this is that adding one to "p" should make it
point to the next integer, which has a memory address that is 4 bytes greater.
Pointers used as arguments to functions
We have already seen that C functions can not alter their arguments. The simple reason for this is that when you call a
function, the compiler passes copies of the values of the arguments to the function. For example, if you have a function
as follow:
void myfunc(int n) {
n = 6;
}
and you call it with
int i = 0;
myfunc(i);
Then "myfunc" is passed the number 0. "myfunc" knows nothing whatsoever about where this number came from. The