Can we have operations between int* and unsigned int?

Question

If I declare

int x = 5 ;
int* p = &x;
unsigned int y = 10 ;
cout << p+y ;

Is this a valid thing to do in C++, and if not, why?

It has no practical use, but is it possible?

Answer 1

The math is valid; the resulting pointer isn't.

When you say ptr + i (where ptr is an int*), that evaluates to the address of an int that's i * sizeof(int) bytes past ptr. In this case, since your pointer points to a single int rather than an array of them, you have no idea (and C++ doesn't say) what's at p+10.

If, however, you had something like

int ii[20] = { 0 };
int *p = ii;
unsigned int y = 10;
cout << p + y;

Then you'd have a pointer you could actually use, because it still points to some location within the array it originally pointed into.

Answer 2

What you are doing in your code snippet is not converting unsigned int to pointer. Instead you are incrementing a pointer by an integer offset, which is a perfectly valid thing to do. When you access the index of an array, you basically take the pointer to the first element and increase it by the integer index value. The result of this operation is another pointer.

If p is a pointer/array, the following two lines are equivalent and valid (supposing the pointed-to-array is large enough)

p[5] = 1;
*(p + 5) = 1;

To convert unsigned int to pointer, you must use a cast

unsigned int i = 5;
char *p = reinterpret_cast<char *>(i);

However this is dangerous. How do you know 5 is a valid address?

A pointer is represented in memory as an unsigned integer type, the address. You CAN store a pointer in an integer. However you must be careful that the integer data type is large enough to hold all the bits in a pointer. If unsigned int is 32-bits and pointers are 64-bits, some of the address information will be lost.

C++11 introduces a new type uintptr_t which is guaranteed to be big enough to hold a pointer. Thus it is safe to cast a pointer to uintptr_t and back again.

It is very rare (should be never in run-of-the-mill programming) that you need to store pointers in integers.

However, modifying pointers by integer offsets is totally valid and common.

Answer 3

A variable of type int is a variable capable of containing an integer value. A variable of type int* is a pointer to a variable copable of containing an integer value.

Every pointer type has the same size and contains the same stuff: A memory address, which the size is 4 bytes for 32-bit arquitectures and 8 bytes for 64-bit arquitectures. What distinguish them is the type of the variable they are poiting to.

Pointers are useful to address buffers and structures allocated dynamically at run time or any sort of variable that is to be used but is stored somewhere else and you have to tell where.

Arithmetic operations with pointers are possible, but they won't do what you think. For instance, summing + 1 to a pointer of type int will increase its value by sizeof(int), not by literally 1, because its a pointer, and the logic here is that you want the next object of this array.

For instance:

int a[] = { 10, 20, 30, 40 };
int *b = a;
printf("%d\n", *b);
b = b + 1;
printf("%d\n", *b);

It will output:

10
20

Because b is pointing to the integer value 10, and when you sum 1 to it, or any variable containing an integer, its then poiting to the next value, 20.

If you want to perform operations with the variable stored at b, you can use:

*b = *b + 3;

Now b is the same pointer, the address has not changed. But the array 10, 20, 30, 40 now contains the values 13, 20, 30, 40, because you increased the element b was poiting to by 3.

Answer 4

Is this a valid thing to do in c++, and if not why?

Yes. cout << p+y; is valid as you can see trying to compile it. Actually p+y is so valid that *(p+y) can be translated to p[y] which is used in C-style arrays (not that I'm suggesting its use in C++).

Valid doesn't mean it actually make sense or that the resulting pointer is valid. Since p points to an int the resulting pointer will be an offset of sizeof(int) * 10 from the location of x. And you are not certain about what's in there.