Pointers, objects, functions and execution - is this even possible?

[code_glitch]

Theoretically a pointer is a memory adsress to something in your program; and a function/procedure is stored in memory too. (I think you see where this is going by now). So is there any way to do the following:L

object
   Task = object
      MainProc: Pointer;
   end;

var
   TT: Task;

procedure foo();
begin
   writeln('HI');
end;

begin
   TT.MainProc := @foo;
   foo();
end.

However I cannot even get this to compile. Theoretically it should work but I have my reservations. I heard you can do this in C or whatever - so I was wondering if it could be done in pascal - since it would make my life sooo much easier. Think about it:
1 engine manages tasks
each task has init, main and end procedures and etc
you would not have to worry about modes and etc - just register your 'task' and let it all run. or something like that.
any pointers folks? (excuse pun)

[Murmandamus]

Generally, the way you do function pointers in Object Pascal is to declare a Function or Procedure type, like so:

Type
    TMyProc = Procedure(X : Integer);

Var
    MyProc : TMyProc;

Procedure Foo(X : Integer);
Begin
    Writeln('Hi!');
    Writeln(X);
End;

Begin
    MyProc := @Foo;
    MyProc(10);
End.

[code_glitch]

Is there no way to use any procedure without defining it? Or putting that into an object? The way you present works, but does sort of defeat the point of the idea...

[LP]

Do you mean something like this:

var
 ExecPtr: Pointer;
begin
 ExecPtr:= @foo;

 asm
  mov eax, ExecPtr
  call eax
 end;
end;

[User137]

Just 1 thing to add to Murmandamus code...

MyProc := @Foo; // This compiles on Freepascal

MyProc := Foo; // This compiles on Delphi

[Mirage]

How you will call a procedure without defining it? How compiler will manage arguments of an undefined procedure?
Nonetheless, you can define a generic procedure (or method and put it into an instance of a class) with variable number of parameters of any type:

type
TMyProc = Procedure(args: array of const) of object;

Procedure TSomeClass.Foo(args: array of const);
Begin
    if lengths(args) > 1 then begin
        Writeln(args[0]);
        Writeln(args[1]);
    end;
End;

var 
  SomeClass: TSomeClass;
  MyProc: TMyProc;

Begin
    MyProc := @SomeClass.Foo;
    MyProc(['Hello!', 10]);
End.

A well-known Format() function works this way. You can see it in VCL sources.
You can also read more on topic "variant open array parameters".

[imcold]

Proc/fn type must be defined, because procedure parameters must be known to call the given procedure correctly. Proc/fn pointers can be used in objects, of course.

Edit: too slow.

[code_glitch]

Thanks for all the replies - will start testing ASAP.

cheers
code_glitch

[arthurprs]

I didn't test, but if you typecast the pointer to a procedure/function type, you can call it.

[wodzu]

Is there no way to use any procedure without defining it? Or putting that into an object? The way you present works, but does sort of defeat the point of the idea...

Maybe you had on your mind without "declaring" instead of "defining"?

With anonymous methods in Delphi you can do things like:

initialization
  with TMyClass.Create do
  begin
    DoStuff(
      procedure(value: string)
      begin
        Writeln(value);
      end);

    Free;
  end;
end.