void * in ANSC

[Mark Jiao]

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");
}

[vippstar]

On Feb 3, 5:13 am, "Mark Jiao" <[e-mail]:

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??

You are performing arithmetic operations with a void * pointer which
is not allowed.
&data[len] means &*(data + len)
Try this
--
while(tmp < (char *)data + len)

[frog]

On 2ÔÂ3ÈÕ, ÉÏÎç11ʱ13·Ö, "Mark Jiao" <[e-mail]:

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");

}- Òþ²Ø±»ÒýÓÃÎÄ×Ö -

- ÏÔʾÒýÓõÄÎÄ×Ö -

??

[Mark Jiao]

ÔÚ Sun, 03 Feb 2008 11:22:09 +0800£¬<vi******@gmail.comдµÀ:

On Feb 3, 5:13 am, "Mark Jiao" <[e-mail]:

>void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??

You are performing arithmetic operations with a void * pointer which
is not allowed.
&data[len] means &*(data + len)

Sorry!
I am very poor English!
How many the memery address would be add?? 1? or No Standards ??

Thanks!

Try this
--
while(tmp < (char *)data + len)

--

[Keith Thompson]

"Mark Jiao" <jz*****@126.comwrites:

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");
}

I think what you're asking is why the compiler prints just a warning
rather than an error message.

Attempting to dereference a void*, as you've done here, is a
constraint violation. The compiler is required to issue some sort of
diagnostic message, but it doesn't have to be a fatal error (the
standard doesn't distinguish between warnings and other diagnostics).

As it happens, at least one major compiler allows, as an extension,
certain operations on void* that are not supported by the language.
If you're using gcc, that explains it.

Most warnings should be treated as errors anyway.

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[pete]

Mark Jiao wrote:

>
ÔÚ Sun, 03 Feb 2008 11:22:09 +0800£¬<vi******@gmail.comдµÀ:

On Feb 3, 5:13 am, "Mark Jiao" <[e-mail]:

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??

You are performing arithmetic operations with a void * pointer which
is not allowed.
&data[len] means &*(data + len)

Sorry!
I am very poor English!
How many the memery address would be add?? 1? or No Standards ??

No Standards for ((void *)data + 1).

Try this
--
while(tmp < (char *)data + len)

1 memery address would be added for ((char *)data + 1).

--
pete

[vippstar]

On Feb 3, 9:32 am, Keith Thompson <[e-mail]:

"Mark Jiao" <[e-mail]:

void printhex(const void *data,size_t len)
{
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");
}

I think what you're asking is why the compiler prints just a warning
rather than an error message.

Attempting to dereference a void*, as you've done here, is a
constraint violation. The compiler is required to issue some sort of
diagnostic message, but it doesn't have to be a fatal error (the
standard doesn't distinguish between warnings and other diagnostics).

I believe, since x[y] expands to (or, is equal to) *(x + y) what the
compiler should diagnose is about arithmetic on a 'void *' pointer.

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Sun, 03 Feb 2008 03:31:07 -0800, vippstar wrote:

On Feb 3, 9:32 am, Keith Thompson <[e-mail]:

>"Mark Jiao" <[e-mail]:

void printhex(const void *data,size_t len) {
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");
}

I think what you're asking is why the compiler prints just a warning
rather than an error message.

Attempting to dereference a void*, as you've done here, is a constraint
violation. The compiler is required to issue some sort of diagnostic
message, but it doesn't have to be a fatal error (the standard doesn't
distinguish between warnings and other diagnostics).

I believe, since x[y] expands to (or, is equal to) *(x + y) what the
compiler should diagnose is about arithmetic on a 'void *' pointer.

You're correct. Dereferencing a void * is allowed, though not
particularly useful, since you can't do anything with the result but
discard it or take its address again. Performing arithmetic on a void *
is not allowed, because void is an incomplete type. It's the same as how
performing arithmetic on int (*)[] is not allowed, because int [] is an
incomplete type.

[Jack Klein]

On Sun, 03 Feb 2008 12:47:45 +0100, Harald van D?k <tr*****@gmail.com>
wrote in comp.lang.c:

On Sun, 03 Feb 2008 03:31:07 -0800, vippstar wrote:

On Feb 3, 9:32 am, Keith Thompson <[e-mail]:

"Mark Jiao" <[e-mail]:
void printhex(const void *data,size_t len) {
unsigned char * tmp = data;
while(tmp < &data[len]) //just warning , ??
printf("%.2X ",*tmp++);
printf("\n");
}

I think what you're asking is why the compiler prints just a warning
rather than an error message.

Attempting to dereference a void*, as you've done here, is a constraint
violation. The compiler is required to issue some sort of diagnostic
message, but it doesn't have to be a fatal error (the standard doesn't
distinguish between warnings and other diagnostics).

I believe, since x[y] expands to (or, is equal to) *(x + y) what the
compiler should diagnose is about arithmetic on a 'void *' pointer.

You're correct. Dereferencing a void * is allowed, though not

Allowed by whom? Certainly not by the C language standard. Can you
cite C&V to the contrary?

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.club.cc.cmu.edu/~ajo/docs/FAQ-acllc.html

[Keith Thompson]

Jack Klein <ja*******@spamcop.netwrites:

On Sun, 03 Feb 2008 12:47:45 +0100, Harald van D?k <tr*****@gmail.com>
wrote in comp.lang.c:

[...]

>You're correct. Dereferencing a void * is allowed, though not

Allowed by whom? Certainly not by the C language standard. Can you
cite C&V to the contrary?

Can you cite C&V that says it's *not* allowed? I checked earlier, and
I was surprised to discover that it does appear to be allowed.

In C99 6.5.3.2, the only constraint for the unary "*" operator is:

The operand of the unary * operator shall have pointer type.

and void* is a pointer type. Obviously there's very little you can do
with the result, but this:

void *ptr = /* some non-null value */
*ptr;

appears to be legal (though not particularly useful).

--
Keith Thompson (The_Other_Keith) <ks***@mib.org>
Nokia
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"

[Army1987]

Keith Thompson wrote:

In C99 6.5.3.2, the only constraint for the unary "*" operator is:

The operand of the unary * operator shall have pointer type.

and void* is a pointer type. Obviously there's very little you can do
with the result, but this:

void *ptr = /* some non-null value */
*ptr;

appears to be legal (though not particularly useful).

This has a curious consequence:
volatile void *ptr = SOMEWHERE;
*ptr;

How many bytes does that access?

--
Army1987 (Replace "NOSPAM" with "email")

[Peter Nilsson]

Army1987 <[e-mail]:

Keith Thompson wrote:

In C99 6.5.3.2, the only constraint for the unary "*"
operator is:

* * The operand of the unary * operator shall have pointer
type. and void* is a pointer type. *Obviously there's very
little you can do with the result, but this:

* * void *ptr = /* some non-null value */
* * *ptr;

appears to be legal (though not particularly useful).

This has a curious consequence:
* * *volatile void *ptr = SOMEWHERE;
* * **ptr;

How many bytes does that access?

None. [How many bytes does any other void expression access?]

--
Peter

[Army1987]

Peter Nilsson wrote:

Army1987 <[e-mail]:

>Â* Â* Â*volatile void *ptr = SOMEWHERE;
Â* Â* Â**ptr;

How many bytes does that access?

None. [How many bytes does any other void expression access?]

(void)memcpy(foo, bar, 42) accesses 42 bytes.

--
Army1987 (Replace "NOSPAM" with "email")

[Army1987]

Army1987 wrote:

(void)memcpy(foo, bar, 42) accesses 42 bytes.

84 bytes, I meant.

--
Army1987 (Replace "NOSPAM" with "email")

[Peter Nilsson]

Army1987 <[e-mail]:

Peter Nilsson wrote:

Army1987 <[e-mail]:

* * *volatile void *ptr = SOMEWHERE;
* * **ptr;
>
How many bytes does that access?

None. [How many bytes does any other void expression
access?]

(void)memcpy(foo, bar, 42) accesses [84] bytes.

How many bytes does the following access?

memcpy;

--
Peter

[Walter Roberson]

In article <fo**********@tdi.cu.mi.it>, Army1987 <ar******@NOSPAM.itwrote:

>Army1987 wrote:

>(void)memcpy(foo, bar, 42) accesses 42 bytes.

>84 bytes, I meant.

How do you arrive at that number? memcpy() does not define
the behaviour if the fields overlap. memmove() is the function
that defines the copying "as if" the data were copied into a
temporary buffer, and if such temporary copies were to take
place then Yes that would increase the byte count, but as you
have not defined the extent to which foo overlaps with bar,
you cannot say with any degree of certainty -exactly- how many
bytes would be accessed or how many times those bytes would be
accessed.
--
"Okay, buzzwords only. Two syllables, tops." -- Laurie Anderson

[Peter Nilsson]

Army1987 <[e-mail]:

Peter Nilsson wrote:

Army1987 <[e-mail]:
* * *volatile void *ptr = SOMEWHERE;
* * **ptr;

How many bytes does that access?
>
None. [How many bytes does any other void expression
access?]

(void)memcpy(foo, bar, 42) accesses [84] bytes.

<snip>

[In light of Harald van Dijk's point on my followup...]
How many bytes does the following access?

memcpy(foo, bar, 0);

If it's none, then why should *memcpy(foo, bar, 0) be
any different? If it isn't different, then why should
dereferencing a volatile void pointer be any different?

--
Peter

[CBFalconer]

Walter Roberson wrote:

>Army1987 wrote:

>>(void)memcpy(foo, bar, 42) accesses 42 bytes.

>84 bytes, I meant.

How do you arrive at that number? memcpy() does not define
the behaviour if the fields overlap. memmove() is the function

.... snip ...

There is a from and a to parameter. They have restrict applied, so
they are different. Each points to a 42 byte area, which is either
examined or modified. 42 + 42 is roughly equal to 84. In base 10.

7.21.2.1 The memcpy function

Synopsis
[#1]
#include <string.h>
void *memcpy(void * restrict s1,
const void * restrict s2,
size_t n);
Description
[#2] The memcpy function copies n characters from the object
pointed to by s2 into the object pointed to by s1. If
copying takes place between objects that overlap, the
behavior is undefined.

Returns
[#3] The memcpy function returns the value of s1.

Please don't strip attributions for any material you quote.

--
[mail]: Chuck F (cbfalconer at maineline dot net)
[page]: <http://cbfalconer.home.att.net>
Try the download section.

--
Posted via a free Usenet account from http://www.teranews.com

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Mon, 04 Feb 2008 18:46:13 -0500, CBFalconer wrote:

Walter Roberson wrote:

[stripped attribution re-inserted]

>>In article <fo**********@tdi.cu.mi.it>, Army1987 <ar******@NOSPAM.it>

wrote:

>>Army1987 wrote:

>>>(void)memcpy(foo, bar, 42) accesses 42 bytes.

>>84 bytes, I meant.

How do you arrive at that number? memcpy() does not define the
behaviour if the fields overlap. memmove() is the function

Please don't strip attributions for any material you quote.

Please don't strip attributions for any material you quote. You stripped
attributions. Walter Roberson didn't, or at least not in the message you
replied to.

[Army1987]

Peter Nilsson wrote:

How many bytes does the following access?

memcpy(foo, bar, 0);

If it's none, then why should *memcpy(foo, bar, 0) be
any different? If it isn't different, then why should
dereferencing a volatile void pointer be any different?

Ok, another example:

volatile struct incomplete *foo = a_function_returning_a_struct_pointer();
*foo;
How many bytes does the statement access?
--
Army1987 (Replace "NOSPAM" with "email")