Thread: creating a new instance of a function?

ok, this kinda follows on my previous post. (i got basic user function calls executing, as well as user created functions being processed and executed) however i need to know how to create a new instance of a function. example.

Code:

void bob(std::string unused_dont_ask_why)
{
	std::cout << "blah";
}

could i do something like this:

Code:

void (*)(string) the_func_pointer = new(bob);

how would i create a function pointer to bob such that it would have a unique address?

thanks guys,

First of all functions don't have instances. Instances are related to processes and threads.

AFAIK a function pointer looks like one of the following. I've done this before but I totally forget what I did. Since I'm not at my compiler right now I cannot test this.

<return type> *FunctionName(<param list>);

or

<return type> (*FunctionName)(<param list>);


Again this looks kinda jiggy so I'm not positive this is correct. But you can do function pointers in C/C++. I used to use XMS which required me to attain a function pointer to the XMShandler which was the main handler for the XMS routines. The address of the handler was return to me via an XMS call and then I assigned my function to point to that handler's address effectively creating a C-like function.

This is similar to the format for an interrupt handler in C.

interrupt (*MyHandler)(void) - for C
interrupt (*MyHandler)(...) - for C++

Thanks a million CornedBee. Just wasn't sure which one was right. Love the typedef - much easier.

ok, i tried fordys answer and it basically works how i wanted. however it leaves me with another problem.
for my code to work i will need the function thats being called to know its address.

Code:

#include <iostream>

void foobar()
{
	std::cout << ADDRESS_OF_THIS_COPY_OF_FUBAR << std::endl;
}

int main()
{
	typedef void(*FP)();
	FP *ptrf = new FP(&foobar);//excuse lack of error handling
	(*ptrf)();
	(*foobar)();
	delete ptrf;
	return 1;
}

thanks

i dont need a new block of code, i need the same block of code accessable from 2 seperate addresses that i could call using pointers. i need a unique address for each function, even if they are identical in what they do.

its required for an index.

There is a very dangerous element to creating functions on the heap. Let's say some moron programmer deletes said function using delete and then calls it later. Very bad medicine my friends.
But Fordy is right in that you could approach it that way but I would definitely limit access to that function via a class so that it could not be deleted accidentally or otherwise. And Fordy was not recommending that you do it that way if I know Fordy as well as I think I do. He is merely showing another way to do it, which is what he specializes in.

i dont need a new block of code, i need the same block of code accessable from 2 seperate addresses that i could call using pointers. i need a unique address for each function, even if they are identical in what they do.

If they are the same function (or block of code) why the heck do you need two unique addresses for each function???

Perhaps and illustration in assembly would suffice.

Code:

__LI   proc
ARGS v1:DWORD,v2:DWORD,f1:QWORD

push bp
mov  bp,sp

fild [v2]
fisub [v1]
fmul [f1]
fiadd [v1]

pop bp

ret

__LI  endp

extern "C" double LI(unsigned long v1,unsigned long v2,double f1)

Now LI will be linked in (assuming you have included the source file or the binary file in the link) and the compiler will give it an address.

If you need to access this function from your program, you simply call it like this:

LI(v1,v2,f1);

or in assembly

call __LI

or

call <some address>

Thankfully we can use function names so we don't have ugly looking call instructions sitting around. Since there are no classes and no protection mechanisms in this code - LI can be called from anywhere inside of your program. So if it is the same block of code - it does not need 2 distinct addresses because that would simply be a copy of the original function and would waste space.
In C this would be flagged as an error and would not compile since the function prototypes would be exactly the same. The compiler will not create two copies of the same function and place them at distinct addresses and you should not either.