C ethics question

[Servé Laurijssen]

Recently, I found myself in the following situation:

There is library software written in C which declares some externals like:

struct METER m1;
struct METER m2;

in different sourcefiles and I have no control over these sources.
Then there's functions that operate on these meters and will generate an
event which passes a METER * to identify which meter has been changed.

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C but in this case it's the
only way to do it. What would you do in such a situation when you work on a
project that has to be finished shortly?
Would you jump high and low to get the library writers to change this into
non UB code or would you continue knowing that it works on the current and
future platforms that this code will run on?

 

[Guest]

Recently, I found myself in the following situation:

There is library software written in C which declares some externals like:

struct METER m1;
struct METER m2;

in different sourcefiles and I have no control over these sources.
Then there's functions that operate on these meters and will generate an
event which passes a METER * to identify which meter has been changed.

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C [...]

No, it isn't.

 

[Richard Heathfield]

Servé Laurijssen said:

Recently, I found myself in the following situation:

There is library software written in C which declares some externals
like:

struct METER m1;
struct METER m2;

[...]

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C

Why?

 

[Servé Laurijssen]

Recently, I found myself in the following situation:

There is library software written in C which declares some externals like:

struct METER m1;
struct METER m2;

in different sourcefiles and I have no control over these sources.
Then there's functions that operate on these meters and will generate an
event which passes a METER * to identify which meter has been changed.

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C [...]

No, it isn't.

oh, I thought that you can only compare pointers if they are declared in the
same object.

struct METER meters[10];

if (m == &m[1]) ..
etc would have worked but comparing "random" pointers is UB.

 

[Richard Heathfield]

Servé Laurijssen said:

Now the comparison of these pointers is UB in C [...]

No, it isn't.

oh, I thought that you can only compare pointers if they are declared
in the same object.

You're thinking of relational < <= >= > comparisons. There is no problem
with equality == != comparisons.

 

[Flash Gordon]

Servé Laurijssen wrote, On 31/03/07 12:36:

Recently, I found myself in the following situation:

There is library software written in C which declares some externals like:

struct METER m1;
struct METER m2;

in different sourcefiles and I have no control over these sources.
Then there's functions that operate on these meters and will generate an
event which passes a METER * to identify which meter has been changed.

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C [...]

No, it isn't.

Please get MSOE to quote properly (it can). All quoted material should
be prefixed with a ">" for each level of quoting. As you are doing it
how are we meant to see what is quoted and what you wrote? I had to
check up for this, and I've fixed it this time.

oh, I thought that you can only compare pointers if they are declared in the
same object.

struct METER meters[10];

if (m == &m[1]) ..
etc would have worked but comparing "random" pointers is UB.

You can compare for equality as long as both fall in to the following
categories (they do not have to be in the same category):
1) null pointer
2) pointer to an object
3) pointer to 1 past the end of an object

Relational operators are more limited.

 

[Barry]

Recently, I found myself in the following situation:

There is library software written in C which declares some externals
like:

struct METER m1;
struct METER m2;

in different sourcefiles and I have no control over these sources.
Then there's functions that operate on these meters and will generate an
event which passes a METER * to identify which meter has been changed.

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C [...]

No, it isn't.

oh, I thought that you can only compare pointers if they are declared in
the same object.

struct METER meters[10];

if (m == &m[1]) ..
etc would have worked but comparing "random" pointers is UB.

You may be confusing this with the behavior of <,>,<=,>=.

Read the standard sections on relational operators and equality
operators.

 

[CBFalconer]

.... snip ...

static void OnChangemeter(struct METER *m)
{
if (m == &m1) ...
if (m == &m2) ...
}

Now the comparison of these pointers is UB in C but in this case
it's the only way to do it. What would you do in such a situation
when you work on a project that has to be finished shortly?

No, it's not UB. Those are equality tests, not relative tests.

 

[Servé Laurijssen]

No, it's not UB. Those are equality tests, not relative tests.

Thanks for clearing that up, funny thing is I thought this was the case
because somebody in this group said this. I thought usenet was always
correct
Shame I cant find that post on google

 

[Richard Heathfield]

Servé Laurijssen said:

Thanks for clearing that up, funny thing is I thought this was the
case because somebody in this group said this. I thought usenet was
always correct

And so it is - eventually!