> > > * 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.
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?
