"Peter Remmers" <p.remmers@expires-2011-03-31.arcornews.de> wrote in message
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.
Good, but I see a "but" coming, so before I read the rest of this. Let me
But you only do that indirectly through pointer arithmetic on "p".
So you agree that term p[0] indexes an array , right we can now move on....