string type troubles

**dwks** · 06-04-2008

Yes, I guess I should have seen that.

Besides, I think I was wrong: you can't add pointers at all. I guess if I thought about it that would make sense . . . .

(Note: you can subtract two arbitrary pointers if you want to, but you'll get undefined behaviour.

)

**Elysia** · 06-04-2008

Who says you can't?

Here's two ways of doing it!

Code:

	const char* c = "c";
	const char* d = c;
	c = (const char*)( c - (const char*)-(int32_t)d );
	c = d;
	c = c + (uint32_t)d;

I admit, it's a hack, but it's possible (although technically, you aren't adding two pointers).
(Don't abuse it, though

)

**dwks** · 06-04-2008

Drat, you can't use unary minus on pointers either.

Code:

#include <stdio.h>
#include <stddef.h>

void *negate(void *data) {
    void *p = 0;
    return (void *)-(data - p);
}

int main() {
    void *a, *b;
    a = &b;
    b = &a;

    printf("&#37;p\n", (void *)(a - negate(b)));

    return 0;
}

Note that ptrdiff_t is the type you get when you subtract two pointers, in C99 at least, and apparently you can negate that . . . .

**Elysia** · 06-04-2008

Well, not in C++. But you can cast it to an integral type, negate it and cast it back. Of course, you'd have to do the actual subtraction first since a pointer can't be signed.

**dwks** · 06-04-2008

Hmm, interesting. I was fiddling with my program, and I came up with this:

Code:

#include <stdio.h>
#include <stddef.h>

ptrdiff_t negate(void *data) {
    void *p = 0;
    return -(data - p);
}

int main() {
    void *a, *b;
    a = &b;
    b = &a;

    printf("&#37;p\n", a - negate(b));

    return 0;
}

It looks like I managed to add two pointers, without using any casts! Am I missing something here?

**tabstop** · 06-04-2008

Provided you don't use -Werror, I guess you're ok. (I got the warnings "pointer of type 'void *' used in subtraction" and "pointer of type 'void *' used in arithmetic", but then I have -pedantic turned on.) And I suppose it's a little bit of luck that negate does the right thing, but I would be surprised to be on a system where it didn't.

Edit to add: although g++ didn't compile the program at all -- "pointer of type 'void *' used in arithmetic" is an error, not a warning, to g++.

**CornedBee** · 06-04-2008

Originally Posted by dwks

It looks like I managed to add two pointers, without using any casts! Am I missing something here?

Yes.

1) Undefined behaviour from subtracting the null pointer from a dereferenceable pointer.
2) As far as the compiler is concerned, you're not adding pointers. You're subtracting pointers, yielding an integer, and you're subtracting an integer from a pointer, yielding a pointer.
3) Why the complicated negate stuff?

Code:

int main() {
    int i, j;
    int *a, *b, *n = 0;
    a = &i;
    b = &j;

    printf("&#37;p\n", a + (b - n));

    return 0;
}

**King Mir** · 06-04-2008

If you're passing an integer type to printf, you should use %x, not %p.

**CornedBee** · 06-05-2008

But the code is passing a pointer.

**Elysia** · 06-05-2008

Originally Posted by dwks

Hmm, interesting. I was fiddling with my program, and I came up with this:

It looks like I managed to add two pointers, without using any casts! Am I missing something here?

That's very C-ish. A c++ compiler would complain the instant you ran that program.
In C++, void** != void*. And it could probably turn up a few other errors, as well.

**dwks** · 06-06-2008

Edit to add: although g++ didn't compile the program at all -- "pointer of type 'void *' used in arithmetic" is an error, not a warning, to g++.

Indeed. I only tried it with GCC . . . . I didn't even think try to it as C++, because I though ptrdiff_t was C99-only.

In C++, void** != void*.

I know you hate command lines, but bear with me here.

Code:

$ cat ppvoid.cpp
#include <iostream>

int main() {
    void *a, *b;
    a = &b;
    b = &a;
    return 0;
}
$ g++ -W -Wall -ansi -pedantic ppvoid.cpp -o ppvoid
$

No warnings at all.

It's true that something like this is invalid

Code:

    void *p = 0;
    void **pp = p;  // error: invalid conversion from ‘void*’ to ‘void**’

but the code I used above compiles for some reason. Another thing:

Code:

    void ***ppp = 0;
    void **pp = ppp;  // g++ doesn't like this
    void *p = pp;  // but is fine with this

Anyway . . . .

2) As far as the compiler is concerned, you're not adding pointers. You're subtracting pointers, yielding an integer, and you're subtracting an integer from a pointer, yielding a pointer.

That's true.

3) Why the complicated negate stuff?

I have no idea.

**CornedBee** · 06-07-2008

You can convert any pointer to void* implicitly, even in C++.

**Elysia** · 06-07-2008

It seems to accept any type, even void*** -> void*. Sillyness, really.
At least it could try to differentiate between pointer levels.
Oh well. It's not like we use void* in C++ very often.
(Yay for templates!)

**cpjust** · 06-07-2008

Originally Posted by Elysia

It seems to accept any type, even void*** -> void*. Sillyness, really.
At least it could try to differentiate between pointer levels.
Oh well. It's not like we use void* in C++ very often.
(Yay for templates!)

If you need to cast among unrelated pointer types, prefer casting via void* instead of using reinterpret_cast directly.