(Received in e-mail, replying in group so people can correct any mistakes I
make)
code segment:
long int * size;
char entry[4][16];
............
size=&entry[row][col];
*************************************
Gcc reported 'assignment of incompatible pointer type'.
MY QUESTION IS:
I understand that pointer is just a memory unit that contains the
address(or starting address)of other data object(i.e. int, float,
array, struct, etc.). So it is just an address. How does C implement
the pointer underlying? Why there can be different pointer types. If
so, what is the difference between an integer pointer type and a float
pointer type, for example?
Thank you!
Ji
And int pointer type and a float pointer type point to different types of
data. int* points to data that contains an integer. float* points to
data
that contains a float. There may be some circumstances where you may wish
to convert between pointer types, but you better know what you're doing.
In your example, you are making size a pointer to an int, but then trying
to
get it to point to a character. The compiler rightfully says, wait a
second
buddy, those are two different types. If you really wish to do this, the
you could use reinterpret_cast to change the type of the pointer. It
would
compile but depending on hwo you are use it could cause all kinds of
problems at run time. I.E.
size = reinterpret_cast<int*>( &entry[row][col] );
Again, this is very dangerous. Especially since a char is only 1
character
and an interger is more (4 on my system, 8 on some, who knows how many on
others).
- Thank you, Jim. What I really plan to do is to assign 4 arbitery bytes
- to an int. I was actually manipulating the bytes in MBR entry, I want
- to read the 4 bytes start from any address I specified(here I use the
- char[] to specify the address).
-
- So how could I get any 4 bytes in the MBR entry and convert it as an
- integer? Thank you again.
-
- Sincerely Ji
size = reinterpret_cast<int*>( somecharpointer );
*may* work for you, or it may not It depends on a lot on the architecture
you plan on running this on.
Some CPUs have problems reading integers that are not aligned on specific
byte boundaries, some do not. I believe (but could be mistaken) that AMD
and Intel are okay with this.
So, say, you had some char pointer pointing to arbitrary data that you can
read. If you are not worried about cross platform compatability, then I
would just point the int pointer to the start of where you think the array
is.
char* Data = SomeFunctionReturningChar*( someparm );
int* IntData = reinterpret_cast<int*>( Data );
At this point, if your architecture isn't too restrictive, you should be
able to read the contents of IntData as an integer, I.E.
std::cout << *IntData;
Should give you some int value, as long as the pointer points to memory you
have rights to read.
Notice, however, that incrementing your int pointer will increment it 4
bytes, not 1, because the compiler thinks it's int data you're pointing to.
++IntData;
will make IntData point to 4 bytes later, not one. Just as
IntData[1];
will look at the 5th through 8th bytes in the data.
Now, there are other ways to do it. There've been times I wanted to look at
data and didn't care to store it, so
std::cout << *reinterpret_cast<int*>( Data );
would give me an int value.
std::cout << *reinterpret_cast<int*>( Data + 1 );
would give me the 2nd through 5th bytes as an int, as would
std::cout << *reinterpret_cast<int*>( &Data[1] );
It really depends on what you are trying to accomplish how you would do it.
Looking and displaying the data the worst that usually can happen is you can
crash your program, reading data you don't own, etc.. Changing the data can
get you in trouble if you're not careful at what your'e pointing at, but
that's pretty much the same for all pointers.
