Question about pointer arithmetic and types

**brooksbp** · 08-17-2008

So I would like to know how a pointer acts based on its type.

Code:

char *ptr; /* char == 1 byte */

So say the memory looks like this; and the pointer points to the byte of memory indicated with x's.

Code:

+--------+--------+--------+--------+
|        |        |xxxxxxxx|        |
+--------+--------+--------+--------+

Now if I cast ptr to be of type int16 (2 bytes), will the memory then be pointing to a chunk that looks like this...?

Code:

ptr = (int16 *)ptr;

+--------+--------+--------+--------+
|        |        |xxxxxxxx|xxxxxxxx|
+--------+--------+--------+--------+

Also, if a pointer of type larger than one byte points to a chunk of memory, if I dereference that pointer and fill it with a value, will it start filling bits from right to left? Like this:

Code:

*ptr = 9;

+--------+--------+--------+--------+
|        |        |xxxxxxxx|xxxx1001|
+--------+--------+--------+--------+

And if I increment the pointer, it will increment by the type that it is? I.e.

Code:

ptr += 1;

+--------+--------+--------+--------+
|        |        |xxxxxxxx|xxxx1001|
+--------+--------+--------+--------+
|eeeeeeee|eeeeeeee|        |        |
+--------+--------+--------+--------+

ptr now points to blocks full of e's and if you were to modify, it starts filling from rightmost e to left...?

Also, if there are any tutorials on not only pointer arithmetic, but on situations where you cast a pointer to different type and start filling memory, etc... would be helpful. Thanks!

**whiteflags** · 08-17-2008

>> Now if I cast ptr to be of type int16 (2 bytes), will the memory then be pointing to a
>> chunk that looks like this...?

You're certainly being clever.

Pointers do not necessarily fill in data from left to right if you're simulating an array. The index operator can help you access any element, and elements are stored where they are assigned, in the order they are assigned.

Casting pointer types without a good reason is usually a bad idea, as evidenced by the warning you ought to receive if you do something odd like assign pointers of incompatible types. That said, casting a pointer to a type usually changes it to the type for the sake of that operation alone.

Code:

#include <stdio.h>

int main (void)
{
    char cs[30];
    char * p = cs;
    printf( "p is at &#37;p\n", (void*)p );

    p++;
    printf( "p is at %p\n", (void*)p );

    p = (long*)p + 16;
    printf( "p is at %p\n", (void*)p );

    return 0;
}

p is at 0012FF40
p is at 0012FF41
p is at 0012FF81

You'll notice that the size of the step is much different because of the type p assumed at the time. p jumped 64 bytes before being printed again.

Now, storing data of another type, like an integer, in the midst of something else like a string is not smart. The underlying bit representation for char and integer are completely different, for example. You would lose the ability to efficiently read and manipulate either the string or the integer. You risk inadvertently corrupting the storage space during a math or string operation.

If you do run into a bug it will be nasty. Do not do that with two types.

**Salem** · 08-17-2008

> xxxxxxxx|xxxx1001
Look up "big endian" and "little endian"

**brooksbp** · 08-22-2008

cool. thanks citizen. I really hate having to use nasty pointer arithmetic... sucks when you can't model or express functionality using formal constructs...

**iMalc** · 08-22-2008

You had it all right (assuming Big Endian at least) up until the diagram with all the E's. You've actually performed ptr -= 1; in that diagram.
A longer type extends to occupying more memory in the positive direction, i.e. the direction you go when you increment the pointer. Here's a little endian demo:

char *ptr;

Code:

+--------+--------+--------+--------+
|xxxxxxxx|        |        |        |
+--------+--------+--------+--------+

*ptr = 6;

Code:

+--------+--------+--------+--------+
|00000110|        |        |        |
+--------+--------+--------+--------+

short *ptr2 = (short*)ptr;

Code:

+--------+--------+--------+--------+
|00000110|xxxxxxxx|        |        |
+--------+--------+--------+--------+

*ptr2 = 9;

Code:

+--------+--------+--------+--------+
|00001001|00000000|        |        |
+--------+--------+--------+--------+

ptr2++;

Code:

+--------+--------+--------+--------+
|        |        |xxxxxxxx|xxxxxxxx|
+--------+--------+--------+--------+

*ptr2 = 10;

Code:

+--------+--------+--------+--------+
|        |        |00001010|00000000|
+--------+--------+--------+--------+

long *ptr3 = (long*)ptr;

Code:

+--------+--------+--------+--------+
|00000110|00000000|00001010|00000000|
+--------+--------+--------+--------+

Thread: Question about pointer arithmetic and types

Thread Tools

Search Thread

Display

Question about pointer arithmetic and types

Similar Threads

Quick Pointer Question

strings Vs. Char pointers

Direct3D problem

Sending non-(char*) data

pointers