Amkcoder wrote, On 23/09/08 17:50:
The reason universities, who make real programmers, use the definition
that a pointer
is a variable that holds the address to another variable in memory, is
because
it is.
I'll admit that the word "pointer" is often used to refer to a variable
of type pointer to something. It's a good way to confuse people though
because that is not the only way the word is commonly used.
Every time you declare a pointer space is allocated for it to hold a
value,
which will be treated as an address. This space has its own address,
just like a variable.
Since you are using the word "pointer" to mean a "pointer variable" then
it not only has its own address just like a variable it *is* a variable.
This leads to another mistake in your tutorial. You say...
The address of memory allocated by a declared variable may be retrieved
with the address of operator for assignment to a pointer, or for
later storage.
This works on any variable but pointers, if it is a pointer one
may retrieve the address it holds by excluding the asterik prefixed
to its identifier.
This is wrong. The address operator "&" works perfectly well on pointer
variables, I know because the standard says so and I use it. Of course,
it doesn't give you the value the pointer variable contains, but in that
respect it is _exactly_the_same_ as every other variable.
So that every time a pointer is declared the same amount of space is
allocated
capable of holding an address. The pointer's type merely indicates how
to treat the data it refers to when it is dereferenced.
So he is an expert,
then call me the professional.
You would not even get through the interview anywhere that I have worked.
Another error is that you seem to think that adding one to a pointer
increments it by one byte and that if you want to increment through some
type larger than a byte you have to add sizeof(type) to a pointer. This
is complete and utter rubbish. You then go on to ignore allignment
issues giving this final piece of badly broken code...
unsigned char *char_ptr=malloc(sizeof(char)+sizeof(short int));
short int *int_ptr=(short int *)char_ptr+1;
*char_ptr=123;
*int_ptr=510;
printf("%d %d",*char_ptr,*int_ptr);
Just for amusement I've expanded it to a complete program...
markg@brenda:~$ cat t.c
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
unsigned char *char_ptr=malloc(sizeof(char)+sizeof(short int));
short int *int_ptr=(short int *)char_ptr+1;
*char_ptr=123;
*int_ptr=510;
printf("%d %d",*char_ptr,*int_ptr);
printf("\n%p %p\n",(void*)char_ptr,(void*)int_ptr);
return 0;
}
markg@brenda:~$ gcc -ansi -pedantic -Wall -Wextra -g3 t.c
markg@brenda:~$ ./a.out
123 510
0x804a008 0x804a00a
markg@brenda:~$
Note that the addresses are two apart not 1 as you thought. This also
means that as on this machine short is two bytes it reads/writes beyond
the end of the allocated memory. For your information I also ran it
through a memory checker which reports this problem...
markg@brenda:~$ valgrind --tool=memcheck ./a.out
==5552== Memcheck, a memory error detector.
==5552== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==5552== Using LibVEX rev 1804, a library for dynamic binary translation.
==5552== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==5552== Using valgrind-3.3.0-Debian, a dynamic binary instrumentation
framework.
==5552== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==5552== For more details, rerun with: -v
==5552==
==5552== Invalid write of size 2
==5552== at 0x80483D6: main (t.c:9)
==5552== Address 0x418d02a is 2 bytes inside a block of size 3 alloc'd
==5552== at 0x4022AB8: malloc (vg_replace_malloc.c:207)
==5552== by 0x80483C0: main (t.c:6)
==5552==
==5552== Invalid read of size 2
==5552== at 0x80483DE: main (t.c:10)
==5552== Address 0x418d02a is 2 bytes inside a block of size 3 alloc'd
==5552== at 0x4022AB8: malloc (vg_replace_malloc.c:207)
==5552== by 0x80483C0: main (t.c:6)
123 510
0x418d028 0x418d02a
==5552==
==5552== ERROR SUMMARY: 2 errors from 2 contexts (suppressed: 11 from 1)
==5552== malloc/free: in use at exit: 3 bytes in 1 blocks.
==5552== malloc/free: 1 allocs, 0 frees, 3 bytes allocated.
==5552== For counts of detected errors, rerun with: -v
==5552== searching for pointers to 1 not-freed blocks.
==5552== checked 60,204 bytes.
==5552==
==5552== LEAK SUMMARY:
==5552== definitely lost: 3 bytes in 1 blocks.
==5552== possibly lost: 0 bytes in 0 blocks.
==5552== still reachable: 0 bytes in 0 blocks.
==5552== suppressed: 0 bytes in 0 blocks.
==5552== Rerun with --leak-check=full to see details of leaked memory.
markg@brenda:~$
One final point, you are not fluent enough in English to write a good
tutorial in English. You lack of fluency probably makes your tutorial
worse than it would be if you wrote it in your first language.
