volatile ptr question

[LBJ]

I have the following C code:

//pHeadLoc contains an address that can be modified externally,
//therefore it is a volatile pointer to a pointer
volatile int** const pHeadLoc = (int**)0x456000;
int* getHeadPtr()
{
return *pHeadLoc;
}

int readHeadPtr()
{
const int* pHeadPtr;
pHeadPtr = getHeadPtr();
return *pHeadPtr;
}
pHeadLoc is a pointer to a pointer to the head of an array.
pHeadLoc will always be constant, but *pHeadLoc can change without the
CPU's knowledge, as can the rest of the contents of said array. when
readHeadPtr() executes the pHeadPtr = getHeadPtr(); statement, I am
pretty sure that i will be getting valid, up-to-date value since
pHeadLoc is volatile. But when I go to access the data in pHeadPtr, I
am not sure that will be getting valid, up-to-date data since pHeadPtr
is not declared volatile. Does anybody know how this will behave?
email me at LB****@yahoo.com.

[Jack Klein]

On 10 Feb 2004 12:30:24 -0800, lb****@yahoo.com (LBJ) wrote in
comp.lang.c:

I have the following C code:

//pHeadLoc contains an address that can be modified externally,
//therefore it is a volatile pointer to a pointer
volatile int** const pHeadLoc = (int**)0x456000;
int* getHeadPtr()
{
return *pHeadLoc;
}

int readHeadPtr()
{
const int* pHeadPtr;
pHeadPtr = getHeadPtr();
return *pHeadPtr;
}
pHeadLoc is a pointer to a pointer to the head of an array.
pHeadLoc will always be constant, but *pHeadLoc can change without the
CPU's knowledge, as can the rest of the contents of said array. when
readHeadPtr() executes the pHeadPtr = getHeadPtr(); statement, I am
pretty sure that i will be getting valid, up-to-date value since
pHeadLoc is volatile. But when I go to access the data in pHeadPtr, I
am not sure that will be getting valid, up-to-date data since pHeadPtr
is not declared volatile. Does anybody know how this will behave?
email me at LB****@yahoo.com.

No, post here, read here.

Why can't you just make pHeadPtr volatile?

const volatile int *pHeadPtr = getHeadPtr();

???

Why do you think you need const in a function this small?

Why not simplify the whole thing to:

int readHeadPtr(void)
{
return *(volatile int *)getHeadPtr();
}

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://www.eskimo.com/~scs/C-faq/top.html
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Anupam]

lb****@yahoo.com (LBJ) wrote in message news:<62*************************@posting.google.c om>...

I have the following C code:

//pHeadLoc contains an address that can be modified externally,
//therefore it is a volatile pointer to a pointer
volatile int** const pHeadLoc = (int**)0x456000;
The correct definition of pHeadLoc would be ::
int* volatile * const pHeadLoc = (int* volatile *)0x456000;
because the address inside of pHeadLoc is volatile from your
statement.


int* getHeadPtr()
{
return *pHeadLoc;
}

int readHeadPtr()
{
const int* pHeadPtr;
pHeadPtr = getHeadPtr();
return *pHeadPtr;
}
pHeadLoc is a pointer to a pointer to the head of an array.
pHeadLoc will always be constant, but *pHeadLoc can change without the
CPU's knowledge, as can the rest of the contents of said array. when
readHeadPtr() executes the pHeadPtr = getHeadPtr(); statement, I am
pretty sure that i will be getting valid, up-to-date value since
pHeadLoc is volatile. But when I go to access the data in pHeadPtr, I
am not sure that will be getting valid, up-to-date data since pHeadPtr
is not declared volatile. Does anybody know how this will behave? This is a no go. It is simply a matter of 'Why cant you do just
that?' It will not behave correctly in all cases. Thats for sure. email me at LB****@yahoo.com.