const void * const x

[codeslinger]

What is the point of the construct in the subject line? Why the use of
two const labels? Does that do something different than const void *x?
And what would void * const x indicate? Thanks in advance :)
--
Tobias DiPasquale

[Keith Thompson]

Da*****@cern.ch (Dan Pop) writes:

In <cc**********@n ntp1.jpl.nasa.g ov> "E. Robert Tisdale"
<E.************ **@jpl.nasa.gov > writes:

Keith Thompson wrote:

Artie Gold writes:

codeslinge r wrote:

>What is the point of the construct in the subject line? Why the use of
>two const labels? Does that do something different than const void *x?
>And what would void * const x indicate? Thanks in advance :)

It means that neither the pointer nor what it points to may be changed.

Right, but since it points to void,
what it points to can't be changed anyway.

#include <string.h>

void *memcpy(void *dest, const void *src, size_t n);

Are you saying that memcpy cannot change what dest points to
just because dest is of type void*?

Nope, he's *obviously* saying that dest itself cannot be used for this
purpose: it has to be converted to an object pointer type first.

Right. On the other hand, a pointer to const void cannot be converted
to a pointer to non-const something-else without an explicit cast, so
the const qualifier in
const void *x;
is meaningful.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Dan Pop]

In <Xn************ *************@2 12.27.42.66> Emmanuel Delahaye <em**********@n oos.fr> writes:

In 'comp.lang.c', Da*****@cern.ch (Dan Pop) wrote:

In 'comp.lang.c', Keith Thompson <ks***@mib.or g> wrote:

Artie Gold <ar*******@aust in.rr.com> writes:
> codeslinger wrote:
> > What is the point of the construct in the subject line? Why the use
> > of two const labels? Does that do something different than const
> > void *x? And what would void * const x indicate? Thanks in advance
> > :)
>
> It means that neither the pointer nor what it points to may be
> changed.

Right, but since it points to void, what it points to can't be changed
anyway.

Nonsense. A pointer can be aliased by a typed one. ^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^ ^^^^^^^^^

But you're still not using the original pointer for this purpose. So,
where is the nonsense?!?
<quote>
"but since it points to void, what it points to can't be changed anyway."
</>

This is wrong. It's not because a pointer is void that the pointed data is
not accessible, at least indirectly.

A pointer to void cannot, by definition, point to any data. It is not
a data pointer. It merely contains an address with no data type attached.
If you want to access any data, you need first to either convert it or
to alias it with a pointer to character type.
The point is that the alias must be const too.

If there is such a point, your example doesn't reflect it.

char s[] = "Hello"; /* R/W data */
void const *p = s; /* not dereferencable. */
char *pa = p; /* Diagnostic */
char const *pb = p; /* Correct. Read only acces */

I can't see any pointer aliasing another pointer in your example. Are
you sure you know what you're talking about?

I came with the idea that 'aliasing' was the result of more than one pointer
pointing to the same location. If you have a better definition, I'd be glad
to ear it.

You were talking about aliasing a pointer, not about aliasing the
pointed to data. See the underlined text above. As it happens, void
pointers can be aliased with character pointers, because they have the
same representation. A concrete example is left as an exercise to the
reader.
Hence, in my example, 'pa' and 'pb' are aliasing 'p'.
Nope. All three are aliasing the pointed data, when dereferenced.
My wording might be incorrect; correctness welcome.

It's your job to check your terminology, as this is not an
English-specific issue.

char *pa = (char *)p;

Evil!

Just as evil as making p a pointer to const in the first place.

? You can even use pa in write mode, because the pointed-to data is
modifiable. It didn't become read-only simply because you pointed a
pointer to const at it.

Far too often, using the type pointer to const means: "I promise not to
use this pointer to modify the data" rather than "this pointer points to
non-modifiable data". Just as in your example.

Hehe! Abusive typecast users will burn in hell ;-)

Except that there is no abuse here. The abuse was in using a pointer to
const in the first place! ;-)

Here's an example of abusive pointer casting:

const char *s = "Hello";
void const *p = s;
char *pa = (char *)p;

Can you understand the difference?

Try avoiding schematic/religious thinking and you'll become a much
better C programmer.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Keith Thompson]

Da*****@cern.ch (Dan Pop) writes:
[...]

A pointer to void cannot, by definition, point to any data. It is not
a data pointer. It merely contains an address with no data type attached.
If you want to access any data, you need first to either convert it or
to alias it with a pointer to character type.

Or pass it to a function that takes a void* or const void* argument,
such as memcpy().

A pointer declared as
void *x;
can be passed as the first argument of memcpy(); a pointer declared as
const void *y;
cannot.

(The memcpy() function might convert it to char* internally, or it
might not even be implemented in C.)

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Dan Pop]

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

Da*****@cern.c h (Dan Pop) writes:
[...]

A pointer to void cannot, by definition, point to any data. It is not
a data pointer. It merely contains an address with no data type attached.
If you want to access any data, you need first to either convert it or
to alias it with a pointer to character type.
Or pass it to a function that takes a void* or const void* argument,
such as memcpy().

Which accesses the data itself, but it still doesn't allow you access to
the data.
A pointer declared as
void *x;
can be passed as the first argument of memcpy(); a pointer declared as
const void *y;
cannot.

Irrelevant, as the address of to the *existing* data is memcpy's *second*
argument. It is obvious that you cannot use the address of a read only
object as the destination of a memory copy operation, no matter how it
is performed.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Keith Thompson]

Da*****@cern.ch (Dan Pop) writes:

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

Da*****@cern.c h (Dan Pop) writes:
[...]

A pointer to void cannot, by definition, point to any data. It is not
a data pointer. It merely contains an address with no data type attached.
If you want to access any data, you need first to either convert it or
to alias it with a pointer to character type.
Or pass it to a function that takes a void* or const void* argument,
such as memcpy().

Which accesses the data itself, but it still doesn't allow you access to
the data.

I don't see how that distinction is relevant.

A pointer declared as
void *x;
can be passed as the first argument of memcpy(); a pointer declared as
const void *y;
cannot.

Irrelevant, as the address of to the *existing* data is memcpy's *second*
argument.

I wasn't talking about memcpy's second argument, I was talking about
its first argument.
It is obvious that you cannot use the address of a read only
object as the destination of a memory copy operation, no matter how it
is performed.

Of course. Have I implied otherwise?

The point I was making was that the "const" keyword in "const void *y"
is semantically significant. I had previously said that "since it
points to void, what it points to can't be changed anyway"; I later
realized that this isn't entirely correct, since it can be changed by
passing the pointer to memcpy().

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Dan Pop]

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

Da*****@cern.c h (Dan Pop) writes:

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

>Da*****@cern.c h (Dan Pop) writes:
>[...]
>> A pointer to void cannot, by definition, point to any data. It is not
>> a data pointer. It merely contains an address with no data type attached.
>> If you want to access any data, you need first to either convert it or
>> to alias it with a pointer to character type.
>
>Or pass it to a function that takes a void* or const void* argument,
>such as memcpy().

Which accesses the data itself, but it still doesn't allow you access to
the data.

I don't see how that distinction is relevant.

Too bad.

>A pointer declared as
> void *x;
>can be passed as the first argument of memcpy(); a pointer declared as
> const void *y;
>cannot.

Irrelevant, as the address of to the *existing* data is memcpy's *second*
argument.

I wasn't talking about memcpy's second argument, I was talking about
its first argument.

Yet, memcpy uses its second argument to access the data, so as usual,
you're talking about something irrelevant to the discussion.

It is obvious that you cannot use the address of a read only
object as the destination of a memory copy operation, no matter how it
is performed.

Of course. Have I implied otherwise?

The point I was making was that the "const" keyword in "const void *y"
is semantically significant.

Of course. Have I implied otherwise?

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de

[Keith Thompson]

Da*****@cern.ch (Dan Pop) writes:

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

Da*****@cern.c h (Dan Pop) writes:

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes: [...] >A pointer declared as
> void *x;
>can be passed as the first argument of memcpy(); a pointer declared as
> const void *y;
>cannot.

Irrelevant, as the address of to the *existing* data is memcpy's *second*
argument.

I wasn't talking about memcpy's second argument, I was talking about
its first argument.

Yet, memcpy uses its second argument to access the data, so as usual,
you're talking about something irrelevant to the discussion.

I'm afraid I've lost track; what discussion is it irrelevant to? It
was entirely relevant to the point I was making (which was to correct
an error I made earlier). If you were having some other discussion,
perhaps you'd care to share it with the rest of us.

--
Keith Thompson (The_Other_Keit h) ks***@mib.org <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
We must do something. This is something. Therefore, we must do this.

[Dan Pop]

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

Da*****@cern.c h (Dan Pop) writes:

In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:

>Da*****@cern.c h (Dan Pop) writes:
>> In <ln************ @nuthaus.mib.or g> Keith Thompson <ks***@mib.or g> writes:[...] >> >A pointer declared as
>> > void *x;
>> >can be passed as the first argument of memcpy(); a pointer declared as
>> > const void *y;
>> >cannot.
>>
>> Irrelevant, as the address of to the *existing* data is memcpy's *second*
>> argument.
>
>I wasn't talking about memcpy's second argument, I was talking about
>its first argument.

Yet, memcpy uses its second argument to access the data, so as usual,
you're talking about something irrelevant to the discussion.

I'm afraid I've lost track; what discussion is it irrelevant to? It
was entirely relevant to the point I was making (which was to correct
an error I made earlier). If you were having some other discussion,
perhaps you'd care to share it with the rest of us.

The discussion was about accessing data through void pointers. IIRC,
you correctly pointed out that void pointers cannot be used for this
purpose. Then, you lost track of the discussion and started talking
about other things.

Dan
--
Dan Pop
DESY Zeuthen, RZ group
Email: Da*****@ifh.de