Re: An array is just a pointer
Am 18.03.2011 01:01, schrieb Paul:
"Peter Remmers"<p.remmers@expires-2011-03-31.arcornews.de> wrote in message
news:4d829286$0$6770$9b4e6d93@newsspool3.arcor-online.net...
Am 17.03.2011 23:00, schrieb Paul:
You don't seem to be clear, maybe you don't like committing yourself to
say
if it is an array or if its not. Let me explain further:
void foo(char p[]){std::cout<< p;}
foo("Is this an array?");
This gives a warning, as the type of the string literal is "const
char[18]", and it only converts to "char*" for compatibility with C.
foo's parameter is lacking the const.
Is an array passed to the function or not? Is an array processed by cout
or
not?
You pass a string literal, which is indeed an unnamed char array, but what
foo receives is a "char*", and I'm pretty sure cout's "operator<<(char*)"
overload is called, which means it also receives a char pointer.
As far as I know (haven't noticed any difference to date), these two are
completely equivalent, and differ only in syntax:
void foo(char p[]) { ... }
void foo(char *p) { ... }
If I print sizeof(p) in foo, I get "4" in both variants on my machine.
Even if you do this:
void foo(char p[18]) { ... }
you still get "4" for sizeof(p).
Only something like this will give "18":
void foo(char (&p)[18]) { .. }
I don't need to know the length of the array because I passed a unlll
terminated string.
Well, it's not like I haven't mentioned null-terminated strings below.
You still seem a bit unclear whether or not the array is received by
function, you state the function receives a char*(not an array). The way you
said it seemed to imply what I put in brackets.
Yes, it receives a pointer to one single lonely int, and it cannot
possibly know whether that poor little int has any neighbours and if so,
how many. The function can go ahead and assume anything it wants, and
try to access as many presumed neighbours as it likes, but unless the
programmer encodes their knowledge of the code outside the function into
these accesses, it is all but certain to be UB.
Am I correct in assuming you think the array I passed is not an array
(inside the function) because i passed a pointer to it?
Yes, inside the function there is only a pointer to one int, which does
indeed have neighbours, but that knowledge gets lost through the
function call.
You think the array is not an array anymore for some reason?
The array is still there, but the knowledge about it does not cross the
point of the function invocation.
It is actually the same with operator new, just reversed. Operator new
creates an array, but it returns a pointer to only one int. From that
pointer alone you would not know how many elements follow the int. You
only know the secret number because you told operator new how many
elements you want, and you can only assume it followed your request.
An array is a pointer in most situations and it's complete nonsense to
suggest its not an array because its a pointer. That's my opinion, I
don't
know yours because you didn't make your opinion too clear.
An array can be converted to a pointer, and once the conversion is done,
the information about the number of elements is lost.
If you pass such a pointer to some function, the receiving side will only
see a pointer to one element and can only speculate as to how many
elements, if any, follow (or even precede!) the element that it points to.
That's why, for functions that are to operate on an array of elements,
usually the length must be passed in a separate parameter. For functions
that receive char*, the assumption is usually that it is a zero-terminated
string, and so a length is not necessary.
The story is a bit different for templates. An example is the _countof
macro I mentioned elsewhere.
As for Leigh and co's opinion about arrays not being arrays because they
are
pointers, well that's obviously complete nonsense, I hope you don't share
their opinion :-S
An array is an array, and a pointer is a pointer. Maybe you think
"identifies an array" is the same as "points to an array"?
There you go, now you now my position (as if it wasn't clear before). Go
ahead and look down on me, like you do with everyone who does not share
your weird beliefs. I will bear it like a man.
Well not really you still didn't really make yourself clear. You said an
array was passed but the function received a pointer.
Its generally known as pass by reference. And you pass a pointer to the
array, if I dereference that pointer I access the arrays data for example:
void voo(char* p){
char c = p[0];
}
Do you agree that I'm indexing the array here, or do you somehow think there
is no array?
I agree you're indexing the array there. But you only do that indirectly
through pointer arithmetic on "p". And you do that with the assumption
that p indeed points to an element of an array and that element has the
neighbors you're trying to access.
Actually, in this case a single int would really suffice, and your
access is well defined, as you're using an offset of zero (barring of
course things like NULL pointers and invalid pointers).
Peter