is a static functions address constant?

is a static functions address constant?
ie..

static void func();
write_to_file(&func);

Restart program...

static void func();
void (*funcPtr) ();
funcPtr = read_from_file();

funcPtr == &func

re: is a static functions address constant?

* Nolan Martin:[color=blue]
> is a static functions address constant?
> ie..
>
> static void func();
> write_to_file(&func);
>
> Restart program...
>
> static void func();
> void (*funcPtr) ();
> funcPtr = read_from_file();
>
> funcPtr == &func[/color]

No.

It is constant during _one_ execution program.

Nothing more is guaranteed by the language, although on
particular systems some functions may or will often or always
end up on the same address -- e.g. crackers use knowledge
of such things to exploit buffer overruns.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

re: is a static functions address constant?

[color=blue]
> * Nolan Martin:[color=green]
> > is a static functions address constant?
> > ie..
> >
> > static void func();
> > write_to_file(&func);
> >
> > Restart program...
> >
> > static void func();
> > void (*funcPtr) ();
> > funcPtr = read_from_file();
> >
> > funcPtr == &func[/color]
>
> No.
>
> It is constant during _one_ execution program.
>
> Nothing more is guaranteed by the language, although on
> particular systems some functions may or will often or always
> end up on the same address -- e.g. crackers use knowledge
> of such things to exploit buffer overruns.
>[/color]

How would I make it so that the example above would work?
I need a way to return to the function across multiple sessions of the
program by reading and writing a "pointer" to the function from a file.

re: is a static functions address constant?

"Nolan Martin" <monkey_drone@hotmail.com> wrote...[color=blue]
>[color=green]
> > * Nolan Martin:[color=darkred]
> > > is a static functions address constant?
> > > ie..
> > >
> > > static void func();
> > > write_to_file(&func);
> > >
> > > Restart program...
> > >
> > > static void func();
> > > void (*funcPtr) ();
> > > funcPtr = read_from_file();
> > >
> > > funcPtr == &func[/color]
> >
> > No.
> >
> > It is constant during _one_ execution program.
> >
> > Nothing more is guaranteed by the language, although on
> > particular systems some functions may or will often or always
> > end up on the same address -- e.g. crackers use knowledge
> > of such things to exploit buffer overruns.
> >[/color]
>
> How would I make it so that the example above would work?
> I need a way to return to the function across multiple sessions of the
> program by reading and writing a "pointer" to the function from a file.[/color]

The "right" way would be to make up some kind of persistent identification
system, like a name that (a) is unique (b) can be associated with a function
and (c) can be written to file and read from it. Such name would have the
association with a function in your code, and you can store the name and
then after reading it do the same thing every time.

A simple way to associate a name with a function is a map that has string
as its key and the function pointer as its value:

typedef std::map<std::string,void(*)()> FuncMap;
FuncMap myfunctionmap;

You will need to have some kind of function to populate the map (and that
is where the string-pointer association will be resolved every time your
program runs):

void populate_map()
{
myfunctionmap["func1"] = func; // 'func' is a function elsewhere
myfunctionmap["more"] = anotherfunc; // and so on
}

Then later if you need to store somthing to a file, store the string part

void write_to_file(void (*f)())
{
// search the map for a value that is the same as 'f', find its key
// store the key
}

and when you read the string from a file, you make the association through
your map:

void (* read_from_file())()
{
std::string s;
// get the string from the file
FuncMap::iterator it = myfunctionmap.find(s);
return (it == myfunctionmap.end()) ? NULL : (*it).second;
}

And so on.

I haven't made sure the code works, it's more to give you the idea of just
one way to do it.

Victor

re: is a static functions address constant?

Nolan Martin wrote:
[color=blue]
> How would I make it so that the example above would work?
> I need a way to return to the function across multiple sessions of the
> program by reading and writing a "pointer" to the function from a file.[/color]



Why would you need such a thing? Just use the function name in every
session of the program.






Regards,

Ioannis Vranos

http://www23.brinkster.com/noicys

re: is a static functions address constant?

Nolan Martin wrote:[color=blue][color=green]
>>* Nolan Martin:
>>[color=darkred]
>>>is a static functions address constant?
>>>ie..
>>>
>>>static void func();
>>>write_to_file(&func);
>>>
>>>Restart program...
>>>
>>>static void func();
>>>void (*funcPtr) ();
>>>funcPtr = read_from_file();
>>>
>>>funcPtr == &func[/color]
>>
>>No.
>>
>>It is constant during _one_ execution program.
>>
>>Nothing more is guaranteed by the language, although on
>>particular systems some functions may or will often or always
>>end up on the same address -- e.g. crackers use knowledge
>>of such things to exploit buffer overruns.
>>[/color]
>
>
> How would I make it so that the example above would work?
> I need a way to return to the function across multiple sessions of the
> program by reading and writing a "pointer" to the function from a file.
>
>[/color]

Break up the "function" into smaller functions or _states_.
Look up state machines.
You could for example, save the current state information, and any
transition information, if relevant. The program then reads the
state information and set the program to enter that state.

Many game programs allow you to save the state enformation, so
that you can return to the function when the program is executed
again.

--
Thomas Matthews

C++ newsgroup welcome message:
http://www.slack.net/~shiva/welcome.txt
C++ Faq: http://www.parashift.com/c++-faq-lite
C Faq: http://www.eskimo.com/~scs/c-faq/top.html
alt.comp.lang.learn.c-c++ faq:
http://www.raos.demon.uk/acllc-c++/faq.html
Other sites:
http://www.josuttis.com -- C++ STL Library book
http://www.sgi.com/tech/stl -- Standard Template Library

re: is a static functions address constant?

> > > * Nolan Martin:[color=blue][color=green][color=darkred]
> > > > is a static functions address constant?
> > > > ie..
> > > >
> > > > static void func();
> > > > write_to_file(&func);
> > > >
> > > > Restart program...
> > > >
> > > > static void func();
> > > > void (*funcPtr) ();
> > > > funcPtr = read_from_file();
> > > >
> > > > funcPtr == &func
> > >
> > > No.
> > >
> > > It is constant during _one_ execution program.
> > >
> > > Nothing more is guaranteed by the language, although on
> > > particular systems some functions may or will often or always
> > > end up on the same address -- e.g. crackers use knowledge
> > > of such things to exploit buffer overruns.
> > >[/color]
> >
> > How would I make it so that the example above would work?
> > I need a way to return to the function across multiple sessions of the
> > program by reading and writing a "pointer" to the function from a file.[/color]
>
> The "right" way would be to make up some kind of persistent identification
> system, like a name that (a) is unique (b) can be associated with a[/color]
function[color=blue]
> and (c) can be written to file and read from it. Such name would have the
> association with a function in your code, and you can store the name and
> then after reading it do the same thing every time.
>
> A simple way to associate a name with a function is a map that has string
> as its key and the function pointer as its value:
>
> typedef std::map<std::string,void(*)()> FuncMap;
> FuncMap myfunctionmap;
>
> You will need to have some kind of function to populate the map (and that
> is where the string-pointer association will be resolved every time your
> program runs):
>
> void populate_map()
> {
> myfunctionmap["func1"] = func; // 'func' is a function elsewhere
> myfunctionmap["more"] = anotherfunc; // and so on
> }
>
> Then later if you need to store somthing to a file, store the string part
>
> void write_to_file(void (*f)())
> {
> // search the map for a value that is the same as 'f', find its key
> // store the key
> }
>
> and when you read the string from a file, you make the association through
> your map:
>
> void (* read_from_file())()
> {
> std::string s;
> // get the string from the file
> FuncMap::iterator it = myfunctionmap.find(s);
> return (it == myfunctionmap.end()) ? NULL : (*it).second;
> }
>
> And so on.
>
> I haven't made sure the code works, it's more to give you the idea of just
> one way to do it.
>
> Victor
>
>[/color]

If only it were that simple...
I am trying to streamline the process of serialization in my program by
storing the location of constructor helper functions (function that returns
"new someclass"), so that all you need to do to make a class serializeable
is give it a helper function and implement a serialize function. the
serialize function will write a "pointer" to the inheritied helper function
then the remaining data. This allows me to implement new classes without
having too much overhead code preparing the lookup table and dramatically
simplifys things.

Ideally this is how I wanted it:

BOOL isSaving; //global flag

class Foo
{
public:
int data;
void* foobar; //can be any class set up for serialization simmilar to
this one
Foo();
~Foo();
static Foo* createInstance() {return new foo;};
virtual /*note that this function is virtual*/ void serialize(FILE*
file;) {
if (::isSaving) { //serialization
write_to_file(&(foobar->createInstance), file);
foobar->serialize(file); //simmilar to this function
write_to_file(data, file);
} else { //deserialization
void* (*fPtr)() = read_from_file(file);
foobar = fPtr();
foobar->serialize(file);
read_from_file(data, file);
}
};
};

the only thing this relys on is that the functions address is allways the
same and that it uses the vtable to look up the serialize function during
deserialization...I wonder how the functions location is stored for a normal
function call, does the compiler not simply replace the name with the
functions address at compile time making the address constant?

int func(int a) { a++; };
x = func(10); //how does it know where to look for the function?

re: is a static functions address constant?

Nolan Martin wrote:[color=blue]
>
>
> If only it were that simple...
> I am trying to streamline the process of serialization in my program by
> storing the location of constructor helper functions (function that returns
> "new someclass"), so that all you need to do to make a class serializeable
> is give it a helper function and implement a serialize function. the
> serialize function will write a "pointer" to the inheritied helper function
> then the remaining data. This allows me to implement new classes without
> having too much overhead code preparing the lookup table and dramatically
> simplifys things.[/color]

Bad idea.
At the moment you do some modifications to your program (and you will do this)
all addresses change. Go the way Victor has suggested.
[snip]
[color=blue]
>
> the only thing this relys on is that the functions address is allways the
> same and that it uses the vtable to look up the serialize function during
> deserialization...I wonder how the functions location is stored for a normal
> function call, does the compiler not simply replace the name with the
> functions address at compile time making the address constant?[/color]

Sure it does. But at the moment you insert eg. a variable somewhere or
so some bug fixes all addresses might change. This is exactly why
programming in assembler is much more productive then hacking opcodes
in hex. The translating program keeps track of where things are located
in memory. You pay for this convinience by not interfering or depending on
a particular memory layout.

--
Karl Heinz Buchegger
kbuchegg@gascad.at