mordekai
asked on
problems with pointer arithmetic
Here's the code: (ignore the fact that it's in a class)
//////////////////////////
//////////////////////////
Block* _blocks[5]; // declaration in class
//////////////////////////
//////////////////////////
void Driver::NextActiveBlock()
{
if( _activeBlock == 0 || _activeBlock == _blocks[MAX_BLOCKS-1] )
_activeBlock = _blocks[0];
else
_activeBlock += sizeof( _blocks[1]); //problem is here.
}
//////////////////////////
//////////////////////////
Ok, _blocks is an array of pointers to Block objects.... so Block**
So i should be able to increment the _activeBlock from one element to the next by adding the size of the pointer within the array (should be 4).
But even if i just replace "sizeof(_blocks[1])" with "4".... _activeBlock doesn't end up pointing to the next element in the list.
Please note: I realize that I could just increment an index into the array but I'm fiddling around with pointer arithmetic. If i'm misunderstanding the way memory is allocated when a array of pointers is declared... can someone correct me or fill me in?
Thanks for your time!
//////////////////////////
//////////////////////////
Block* _blocks[5]; // declaration in class
//////////////////////////
//////////////////////////
void Driver::NextActiveBlock()
{
if( _activeBlock == 0 || _activeBlock == _blocks[MAX_BLOCKS-1] )
_activeBlock = _blocks[0];
else
_activeBlock += sizeof( _blocks[1]); //problem is here.
}
//////////////////////////
//////////////////////////
Ok, _blocks is an array of pointers to Block objects.... so Block**
So i should be able to increment the _activeBlock from one element to the next by adding the size of the pointer within the array (should be 4).
But even if i just replace "sizeof(_blocks[1])" with "4".... _activeBlock doesn't end up pointing to the next element in the list.
Please note: I realize that I could just increment an index into the array but I'm fiddling around with pointer arithmetic. If i'm misunderstanding the way memory is allocated when a array of pointers is declared... can someone correct me or fill me in?
Thanks for your time!
Last Comment
ozo
_activeBlock += 1; //should do what you want
ASKER CERTIFIED SOLUTION
THIS SOLUTION IS ONLY AVAILABLE TO MEMBERS.
View this solution by signing up for a free trial.
Members can start a 7-Day free trial and enjoy unlimited access to the platform.
ozo,
> _activeBlock += 1; //should do what you want
It will not ... for the same reasons ... _activeBlock + 1 will increment the value held in _activeblock (using pointer arithmetic ofcourse) but it will not make it point to the next element in the list of _blocks[]
mordekai,
refer to this link for a previous discussion
http:Q_20823846.html
Sunnycoder
> _activeBlock += 1; //should do what you want
It will not ... for the same reasons ... _activeBlock + 1 will increment the value held in _activeblock (using pointer arithmetic ofcourse) but it will not make it point to the next element in the list of _blocks[]
mordekai,
refer to this link for a previous discussion
http:Q_20823846.html
Sunnycoder
Think about this situation:
int * pint = NULL;
pint++;
the value of pint should be the sizeof(int) that is 4;
_activeBlock seemingly is a pointer to class Block, so when
_activeBlock += 4
the value of _activeBlock is actually added by 4*N,where N is decided by the compiler;
so just try ((int*)_activeBlock)++;
hope these help.
int * pint = NULL;
pint++;
the value of pint should be the sizeof(int) that is 4;
_activeBlock seemingly is a pointer to class Block, so when
_activeBlock += 4
the value of _activeBlock is actually added by 4*N,where N is decided by the compiler;
so just try ((int*)_activeBlock)++;
hope these help.
ASKER
sunnycoder: thanks for the speedy input. i'm trying to absorb all the information you have set before me :)
beavis_shenzhen:
"the value of _activeBlock is actually added by 4*N,where N is decided by the compiler;"
can you explain to me why 'N' is decided by the compiler? _activeBlock points to an object of type Block.. which contains variables whose size is known at compile time ( i think ). are you saying that 'N' can be variable? What would I have to do to simply use _activeBlock like an iterator.... increment through the _blocks array element by element (without indexing into the array that is).
thanks again for your time
beavis_shenzhen:
"the value of _activeBlock is actually added by 4*N,where N is decided by the compiler;"
can you explain to me why 'N' is decided by the compiler? _activeBlock points to an object of type Block.. which contains variables whose size is known at compile time ( i think ). are you saying that 'N' can be variable? What would I have to do to simply use _activeBlock like an iterator.... increment through the _blocks array element by element (without indexing into the array that is).
thanks again for your time
ASKER
sunnycoder: It sounds like you're saying that it isn't possible to iterate through the array that i've created due to the fact that it isn't guaranteed to be contiguous? Is that right?
what I mean is that N is decided by the size of class Block.
consider:
char * pChar = NULL;
int * pInt = NULL;
double * pDouble = NULL;
CDialog * pDialog = NULL;
pChar++;//value is 00000001
pInt++;//value is 00000004
pDouble++;//value is 00000008
pDialog++// value is 00000074
so you know what I mean.
consider:
char * pChar = NULL;
int * pInt = NULL;
double * pDouble = NULL;
CDialog * pDialog = NULL;
pChar++;//value is 00000001
pInt++;//value is 00000004
pDouble++;//value is 00000008
pDialog++// value is 00000074
so you know what I mean.
mordekai,
The array is contiguous but the values held in it are not
int b[5] = { 10,25,11,6,90};
int a = b[0];
If you want a to successively hold values held in b (i.e. b[1] b[2] b[3] ... )
then clearly a = a + sizeof(int); is not the way to go ...
you need to iterate over b
int i = 0
a = b[i++]; is the way to be used ....
replace int by Block *, a by _blocks and b by _activeBlock to arrive at your analogy
Sunnycoder
The array is contiguous but the values held in it are not
int b[5] = { 10,25,11,6,90};
int a = b[0];
If you want a to successively hold values held in b (i.e. b[1] b[2] b[3] ... )
then clearly a = a + sizeof(int); is not the way to go ...
you need to iterate over b
int i = 0
a = b[i++]; is the way to be used ....
replace int by Block *, a by _blocks and b by _activeBlock to arrive at your analogy
Sunnycoder
ASKER
<sigh> i just spent 3 or 4 hours trying to write/debug/research this problem... because i thought i understood pointers. lol
thanks for the clarification sunnycoder!
thanks for the clarification sunnycoder!
glad to be of assistance :o)
what did u initialise _activeBlock with ??
was it
Block * _activeBlock;
OR
Block ** _activeBlock;
If it is the first one, i may suggest
_activeBlock += sizeof( Block *);
Avik.
was it
Block * _activeBlock;
OR
Block ** _activeBlock;
If it is the first one, i may suggest
_activeBlock += sizeof( Block *);
Avik.
ASKER
Avik77
the first one. and I first tried _activeBlock += sizeof( Block* );
Block* evaluates to 4, which when added to _activeBlock... does not point to the next element in _blocks.
one thing that I failed to mention in the question.. which (now that i think about it) may have something to do with my problem... each Block (the object to which a member of _blocks points) is declared with the new operator. So they're allocated memory is in no way contiguous with the elements of _blocks.
It makes sense to me that if _blocks is allocated as such:
array[0] array[0] array[0] array[0] array[0]
[ Block* ] [ block* ] [ block* ] [ block* ] [ block* ]
then if you create a new pointer 'ptr', and point it to array[0], then you should be able to add the sizeof[Block*] (via the function mentioned in msdn help files) to 'ptr' in order to point it to the next element in the list.
I clearly have more research to do.
the first one. and I first tried _activeBlock += sizeof( Block* );
Block* evaluates to 4, which when added to _activeBlock... does not point to the next element in _blocks.
one thing that I failed to mention in the question.. which (now that i think about it) may have something to do with my problem... each Block (the object to which a member of _blocks points) is declared with the new operator. So they're allocated memory is in no way contiguous with the elements of _blocks.
It makes sense to me that if _blocks is allocated as such:
array[0] array[0] array[0] array[0] array[0]
[ Block* ] [ block* ] [ block* ] [ block* ] [ block* ]
then if you create a new pointer 'ptr', and point it to array[0], then you should be able to add the sizeof[Block*] (via the function mentioned in msdn help files) to 'ptr' in order to point it to the next element in the list.
I clearly have more research to do.
_activeBlock += sizeof( *_activeBlock );
does not point to the next *_activeBlock
_activeBlock += 1;
points to the next *_activeBlock;
does not point to the next *_activeBlock
_activeBlock += 1;
points to the next *_activeBlock;
apparently what mordekai wanted was _activeBlock to hold next element in _blocks[]
C
C is a general-purpose, imperative computer programming language, supporting structured programming, lexical variable scope and recursion, while a static type system prevents many unintended operations. By design, C provides constructs that map efficiently to typical machine instructions, so it has found lasting use in applications that had formerly been coded in assembly language, including operating systems as well as various application software for computers ranging from supercomputers to embedded systems. It is distinct from C++ (which has its roots in C) and C#, and many later languages have borrowed directly or indirectly from C.
23K
Questions
--
Followers
--
Top Experts
Get a personalized solution from industry experts
TRUSTED BY
