其实定义那些所谓的变量,还是函数,对那些“变量”的操作和对函数的操作是一样的。
  比如对“变量” IcmSendEcho可以这样使用:
  IcmSendEcho(MyIcmpHandle,MyDestAddress);

解决方案 »

  1.   

    这样的声明 右边的只是一个 关键字function ,有的加几个参数是不是左边就是它的大名?定义一个实例就可以象楼上兄弟所言...这样直接定义一个函数 如
      IcmSendEcho(MyIcmpHandle,MyDestAddress);
    不是更加简单?
      

  2.   

    我仔细看原程序发现它 这样使用的:首先
       在Interface  里又这里的声明
       Ticmpcreatefile = function: Thandle; stdcall;
       hICMP: THANDLE;
    然后
        Private 里这里定义:
     IcmpCreateFile : TIcmpCreateFile;使用
        @ICMPCreateFile  := GetProcAddress(hICMPdll, 'IcmpCreateFile');
        hICMP := IcmpCreateFile;
    难道 @ICMPCreateFile   是个指针 
      

  3.   

    下面这一段是DELPHI帮助里关于方法指针的解释,看完这些就会明白的Procedural types allow you to treat procedures and functions as values that can be assigned to variables or passed to other procedures and functions. For example, suppose you define a function called Calc that takes two integer parameters and returns an integer:function Calc(X,Y: Integer): Integer;You can assign the Calc function to the variable F:var F: function(X,Y: Integer): Integer;F := Calc;If you take any procedure or function heading and remove the identifier after the word procedure or function, what抯 left is the name of a procedural type. You can use such type names directly in variable declarations (as in the example above) or to declare new types:type  TIntegerFunction = function: Integer;
      TProcedure = procedure;
      TStrProc = procedure(const S: string);
      TMathFunc = function(X: Double): Double;
    var
      F: TIntegerFunction;             { F is a parameterless function that returns an integer }
      Proc: TProcedure;                { Proc is a parameterless procedure }
      SP: TStrProc;                    { SP is a procedure that takes a string parameter }
      M: TMathFunc;                    { M is a function that takes a Double (real) parameter                                        and returns a Double }
    procedure FuncProc(P: TIntegerFunction);  { FuncProc is a procedure whose only parameter 
                                                  is a parameterless integer-valued function }The variables above are all procedure pointers梩hat is, pointers to the address of a procedure or function. If you want to reference a method of an instance object (see Classes and objects), you need to add the words of object to the procedural type name. For exampletype  TMethod = procedure of object;
      TNotifyEvent = procedure(Sender: TObject) of object;These types represent method pointers. A method pointer is really a pair of pointers; the first stores the address of a method, and the second stores a reference to the object the method belongs to. Given the declarationstype  TNotifyEvent = procedure(Sender: TObject) of object;
      TMainForm = class(TForm)
        procedure ButtonClick(Sender: TObject);
        ...
      end;
    var
      MainForm: TMainForm;
      OnClick: TNotifyEventwe could make the following assignment.OnClick := MainForm.ButtonClick;Two procedural types are compatible if they havethe same calling convention,
    the same return value (or no return value), and
    the same number of parameters, with identically typed parameters in corresponding positions. (Parameter names do not matter.)Procedure pointer types are always incompatible with method pointer types. The value nil can be assigned to any procedural type.
    Nested procedures and functions (routines declared within other routines) cannot be used as procedural values, nor can predefined procedures and functions. If you want to use a predefined routine like Length as a procedural value, write a wrapper for it:function FLength(S: string): Integer;begin
      Result := Length(S);
    end;Procedural types in statements and expressions