is a static functions address constant?

Discussion in 'C++' started by Nolan Martin, Jul 17, 2004.

  1. Nolan Martin

    Nolan Martin Guest

    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
     
    Nolan Martin, Jul 17, 2004
    #1
    1. Advertising

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

    --
    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?
     
    Alf P. Steinbach, Jul 17, 2004
    #2
    1. Advertising

  3. Nolan Martin

    Nolan Martin Guest


    > * 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.
     
    Nolan Martin, Jul 18, 2004
    #3
  4. "Nolan Martin" <> wrote...
    >
    > > * 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
     
    Victor Bazarov, Jul 18, 2004
    #4
  5. Nolan Martin wrote:

    > 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
     
    Ioannis Vranos, Jul 18, 2004
    #5
  6. Nolan Martin wrote:
    >>* 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.
    >
    >


    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
     
    Thomas Matthews, Jul 18, 2004
    #6
  7. Nolan Martin

    Nolan Martin Guest

    > > > * 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?
     
    Nolan Martin, Jul 19, 2004
    #7
  8. Nolan Martin wrote:
    >
    >
    > 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.

    --
    Karl Heinz Buchegger
     
    Karl Heinz Buchegger, Jul 19, 2004
    #8
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Replies:
    1
    Views:
    578
    Chris Uppal
    Nov 17, 2005
  2. Christopher M. Lusardi
    Replies:
    1
    Views:
    4,111
  3. Martin Magnusson
    Replies:
    2
    Views:
    517
    John Harrison
    Oct 8, 2004
  4. Tor Erik Soenvisen
    Replies:
    14
    Views:
    576
    Tim Roberts
    Nov 23, 2006
  5. John Koleszar

    address of static array element as address constant

    John Koleszar, Jul 7, 2008, in forum: C Programming
    Replies:
    7
    Views:
    632
    John Koleszar
    Jul 15, 2008
Loading...

Share This Page