is a static functions address constant?

[Nolan Martin]

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

 

[Alf P. Steinbach]

* Nolan Martin:

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.

 

[Nolan Martin]

* Nolan Martin:

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.

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.

 

[Victor Bazarov]

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.

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

 

[Ioannis Vranos]

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.

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

 

[Thomas Matthews]

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.

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

 

[Nolan Martin]

* Nolan Martin:

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.

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

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?

 

[Karl Heinz Buchegger]

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.

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]

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?

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.