Was young

Delphi的指针操作和C的指针操作对比比较全面，转帖收录备用

     浅谈Object Pascal的指针

大家都认为，C语言之所以强大，以及其自由性，很大部分体现在其灵活的指针运用上。因此，说指针是C语言的灵魂，一点都不为过。同时，这种说法也让很多人产生误解，似乎只有C语言的指针才能算指针。Basic不支持指针，在此不论。其实，Pascal语言本身也是支持指针的。从最初的Pascal发展至今的Object Pascal，可以说在指针运用上，丝毫不会逊色于C语言的指针。

以下内容分为八个部分，分别是
一、类型指针的定义
二、无类型指针的定义
三、指针的解除引用
四、取地址（指针赋值）
五、指针运算
六、动态内存分配
七、字符数组的运算
八、函数指针


一、类型指针的定义。对于指向特定类型的指针，在C中是这样定义的：
int *ptr;
char *ptr;
与之等价的Object Pascal是如何定义的呢？
var
ptr : ^Integer;
ptr : ^char;
其实也就是符号的差别而已。

二、无类型指针的定义。C中有void *类型，也就是可以指向任何类型数据的指针。Object Pascal为其定义了一个专门的类型：Pointer。于是，
ptr : Pointer;
就与C中的
void *ptr;
等价了。

三、指针的解除引用。要解除指针引用（即取出指针所指区域的值），C 的语法是 (*ptr)，Object Pascal则是 ptr^。

四、取地址（指针赋值）。取某对象的地址并将其赋值给指针变量，C 的语法是
ptr = &Object;
Object Pascal 则是
ptr := @Object;
也只是符号的差别而已。

五、指针运算。在C中，可以对指针进行移动的运算，如：
char a[20];  
char *ptr=a;  
ptr++;
ptr+=2;
当执行ptr++;时，编译器会产生让ptr前进sizeof(char)步长的代码，之后，ptr将指向a[1]。ptr+=2;这句使得ptr前进两 个sizeof(char)大小的步长。同样，我们来看一下Object Pascal中如何实现：
var
  a : array [1..20] of Char;
  ptr : PChar; //PChar 可以看作 ^Char
begin
  ptr := @a;
  Inc(ptr); // 这句等价于 C 的 ptr++;
  Inc(ptr, 2); //这句等价于 C 的 ptr+=2;
end;

六、动态内存分配。C中，使用malloc()库函数分配内存，free()函数释放内存。如这样的代码：
int *ptr, *ptr2;
int i;
ptr = (int*) malloc(sizeof(int) * 20);
ptr2 = ptr;
for (i=0; i<20; i++){
  *ptr = i;
  ptr++;
}
free(ptr2);
Object Pascal中，动态分配内存的函数是GetMem()，与之对应的释放函数为FreeMem()（传统Pascal中获取内存的函数是New()和 Dispose()，但New()只能获得对象的单个实体的内存大小，无法取得连续的存放多个对象的内存块）。因此，与上面那段C的代码等价的 Object Pascal的代码为：
var ptr, ptr2 : ^integer;
  i : integer;
begin
  GetMem(ptr, sizeof(integer) * 20);
    //这句等价于C的 ptr = (int*) malloc(sizeof(int) * 20);
  ptr2 := ptr; //保留原始指针位置
  for i := 0 to 19 do
  begin
    ptr^ := i;
    Inc(ptr);
  end;
  FreeMem(ptr2);
end;
对于以上这个例子（无论是C版本的，还是Object Pascal版本的），都要注意一个问题，就是分配内存的单位是字节（BYTE），因此在使用GetMem时，其第二个参数如果想当然的写成 20，那么就会出问题了（内存访问越界）。因为GetMem(ptr, 20);实际只分配了20个字节的内存空间，而一个整形的大小是四个字节，那么访问第五个之后的所有元素都是非法的了（对于malloc()的参数同样）。

七、字符数组的运算。C语言中，是没有字符串类型的，因此，字符串都是用字符数组来实现，于是也有一套str打头的库函数以进行字符数组的运算，如以下代码：
char str[15];
char *pstr;
strcpy(str, "teststr");
strcat(str, "_testok");
pstr = (char*) malloc(sizeof(char) * 15);
strcpy(pstr, str);
printf(pstr);
free(pstr);
而在Object Pascal中，有了String类型，因此可以很方便的对字符串进行各种运算。但是，有时我们的Pascal代码需要与C的代码交互（比如：用 Object Pascal的代码调用C写的DLL或者用Object Pascal写的DLL准备允许用C写客户端的代码）的话，就不能使用String类型了，而必须使用两种语言通用的字符数组。其实，Object Pascal提供了完全相似C的一整套字符数组的运算函数，以上那段代码的Object Pascal版本是这样的：
var str : array [1..15] of char;
  pstr : PChar; //Pchar 也就是 ^Char
begin
  StrCopy(@str, 'teststr'); //在C中，数组的名称可以直接作为数组首地址指针来用
          //但Pascal不是这样的，因此 str前要加上取地址的运算符
  StrCat(@str, '_testok');
  GetMem(pstr, sizeof(char) * 15);
  StrCopy(pstr, @str);
  Write(pstr);
  FreeMem(pstr);
end;

八、函数指针。在动态调用DLL中的函数时，就会用到函数指针。假设用C写的一段代码如下：
typedef int (*PVFN)(int); //定义函数指针类型
int main()
{
  HMODULE hModule = LoadLibrary("test.dll");
PVFN pvfn = NULL;
  pvfn = (PVFN) GetProcAddress(hModule, "Function1");
  pvfn(2);
  FreeLibrary(hModule);
}
就我个人感觉来说，C语言中定义函数指针类型的typedef代码的语法有些晦涩，而同样的代码在Object Pascal中却非常易懂：
type PVFN = Function (para : Integer) : Integer;
var
  fn : PVFN;
    //也可以直接在此处定义，如：fn : function (para:Integer):Integer;
  hm : HMODULE;
begin
  hm := LoadLibrary('test.dll');
  fn := GetProcAddress(hm, 'Function1');
  fn(2);
  FreeLibrary(hm);
end;
 

补充（蓝蓝） 其他指针（类似的指针）

接口是什么  接口就是指针

事件是什么 事件也是指针，
我们可以这样申明
type
  OnMouseOn=procedure of object;//使用object关键字定义一个 过程或者函数的指针，让他来关联事件
  TClass1=class
    public
      OnMouse:procedure of object;
    end;
   如果写成
    class.onmouse:=form1.onmousedown//这里进行了过程指针指向了。form1的一个具体事件的

 2006-7-10 10:09:17    指针详细。

指针的表达方法
   
   Const
      const PI: ^Integer = @I;


    ^integer=@I=Pointer=@MyProc
     都是指针
    而
      Data^是指针的具体内容。

请举例如何定义指针常量和常量指针
 
 

参数传递中的指针常量就不必说了吧——和非指针的常量一样的。

  这是一个标准的Const Pointer的例子：

var
  A:Integer=100;
const
  PA:PInteger=@A;
procedure TForm1.Button1Click(Sender: TObject);
begin
  Caption:=IntToHex(Integer(PA),8);
end;

  下面是一个用函数来模拟无法预先决定值的常量指针的例子：

Unit A;
interface
function PointerA:Pointer;
implementation
var
  ObjA:TXXX; //ObjA运行后才能被动态的创建
function PointerA:Pointer;
begin
  Result:=@ObjA;
end;
...

  这样，在UnitA之外的地方，PointerA地返回值就是常量了:)
 

在基于Windows平台的程序设计中，事件（event）是一个很重要的概念。因为在几乎所有的Windows应用程序中，都会涉及大量的异步调用，比如响应点击按钮、处理Windows系统消息等，这些异步调用都需要通过事件的方式来完成。即使在下一代开发平台——.NET中也不例外。

那么什么是事件呢？所谓事件，就是由某个对象发出的消息，这个消息标志着某个特定的行为发生了，或者某个特定的条件成立了。比如用户点击了鼠标、socket上有数据到达等。那个触发（raise）事件的对象称为事件的发送者（event sender），捕获并响应事件的对象称为事件的接收者（event receiver）。

在这里，我们将要讨论的是，在.NET的主流开发语言C#中如何使用自定义的事件来实现我们自己的异步调用。

在C#中，事件的实现依赖于delegate，因此我们有必要先了解一下delegate的概念。

C# Delegate

delegate是C#中的一种类型，它实际上是一个能够持有对某个方法的引用的类。与其它的类不同，delegate类能够拥有一个签名（signature），并且它只能持有与它的签名相匹配的方法的引用。它所实现的功能与C/C++中的函数指针十分相似。它允许你传递一个类A的方法m给另一个类B的对象，使得类B的对象能够调用这个方法m。但与函数指针相比，delegate有许多函数指针不具备的优点。首先，函数指针只能指向静态函数，而delegate既可以引用静态函数，又可以引用非静态成员函数。在引用非静态成员函数时，delegate不但保存了对此函数入口指针的引用，而且还保存了调用此函数的类实例的引用。其次，与函数指针相比，delegate是面向对象、类型安全、可靠的受控（managed）对象。也就是说，runtime能够保证delegate指向一个有效的方法，你无须担心delegate会指向无效地址或者越界地址。

实现一个C# delegate是很简单的，通过以下3个步骤即可实现一个delegate：

1． 声明一个delegate对象，它应当与你想要传递的方法具有相同的参数和返回值类型。

2． 创建delegate对象，并将你想要传递的函数作为参数传入。

3． 在要实现异步调用的地方，通过上一步创建的对象来调用方法。

下面是一个简单的例子：

using System;  
public class MyDelegateTest  
{  
// 步骤1，声明delegate对象  
public delegate void MyDelegate(string name);  
// 这是我们欲传递的方法，它与MyDelegate具有相同的参数和返回值类型  
public static void MyDelegateFunc(string name)  
{  
Console.WriteLine("Hello, {0}", name);  
}  
 
public static void Main()  
{  
// 步骤2，创建delegate对象  
MyDelegate md = new MyDelegate(MyDelegateTest.MyDelegateFunc);  
// 步骤3，调用delegate  
md("sam1111");  
}  
} 

输出结果是：Hello, sam1111

了解了delegate，下面我们来看看，在C#中对event是如何处理的。

C# event

C#中的事件处理实际上是一种具有特殊签名的delegate，象下面这个样子：

public delegate void MyEventHandler(object sender, MyEventArgs e);

其中的两个参数，sender代表事件发送者，e是事件参数类。MyEventArgs类用来包含与事件相关的数据，所有的事件参数类都必须从System.EventArgs类派生。当然，如果你的事件不含参数，那么可以直接用System.EventArgs类作为参数。

就是这么简单，结合delegate的实现，我们可以将自定义事件的实现归结为以下几步：

1． 定义delegate对象类型，它有两个参数，第一个参数是事件发送者对象，第二个参数是事件参数类对象。

2． 定义事件参数类，此类应当从System.EventArgs类派生。如果事件不带参数，这一步可以省略。

3． 定义事件处理方法，它应当与delegate对象具有相同的参数和返回值类型。

4． 用C# event关键字定义事件对象，它同时也是一个delegate对象。

5． 用+=操作符添加事件到事件队列中（-=操作符能够将事件从队列中删除）。

6． 在需要触发事件的地方用调用delegate的方式写事件触发方法。一般来说，此方法应为protected访问限制，既不能以public方式调用，但可以被子类继承。名字是OnEventName。

7． 在适当的地方调用事件触发方法触发事件。

下面是一个简单的例子：

using System;  
public class EventTest  
{  
// 步骤1，定义delegate对象  
public delegate void MyEventHandler(object sender, System.EventArgs e);  
// 步骤2省略  
public class MyEventCls  
{  
// 步骤3，定义事件处理方法，它与delegate对象具有相同的参数和返回值类型  
public void MyEventFunc(object sender, System.EventArgs e)  
{  
Console.WriteLine("My event is ok!");  
}  
}  
// 步骤4，用event关键字定义事件对象  
private event MyEventHandler myevent;  
private MyEventCls myecls;  
public EventTest()  
{  
myecls = new MyEventCls();  
// 步骤5，用+=操作符将事件添加到队列中  
this.myevent += new MyEventHandler(myecls.MyEventFunc);  
}  
// 步骤6，以调用delegate的方式写事件触发函数  
protected void OnMyEvent(System.EventArgs e)  
{  
if(myevent != null)  
myevent(this, e);  
}  
 
public void RaiseEvent()  
{  
EventArgs e = new EventArgs();  
// 步骤7，触发事件  
OnMyEvent(e);  
}  
 
public static void Main()  
{  
EventTest et = new EventTest();  
Console.Write("Please input a:");  
string s = Console.ReadLine();  
if(s == "a")  
{  
et.RaiseEvent();  
}  
else 
{  
Console.WriteLine("Error");  
}  
}  
} 

输出结果如下，黑体为用户的输入：

Please input ‘a’: a

My event is ok!

小结

通过上面的讨论，我们大体上明白了C# delegate和C# event的概念，以及如何在C#中使用它们。我个人认为，delegate在C#中是一个相当重要的概念，合理运用的话，可以使一些相当复杂的问题变得很简单。有时我甚至觉得，delegate甚至能够有指针的效果，除了不能直接访问物理地址。而且事件也是完全基于delegate来实现的。由于能力有限，本文只是对delegate和event的应用作了一个浅显的讨论，并不深入，我希望本文能够起到抛砖引玉的作用。真正想要对这两个概念有更深入的了解的话，还是推荐大家看MSDN。

delegate(委托)是C#中一项令我比较费解的东西,在网上查到以下代码用以学习,根据MSDN中的说明,使用delegate可以让一个类(A)访问另一个类(B)的函数而不必是类(B)的成员.

在以下的代码中,在名称空间中定义了一个delegate对象vvCallBack(),它的参数就是准备要调用的目标函数(PrintSearchResult)的参数(string s). 这里注意,目标函数(PrintSearchResult)是一个private函数.

在类A中,通过第52行(public void SearchData(string SearchCondition, vvCallBack ClientDefinedProcedure))调用目标函数,这里无视目标函数是在其他哪个类中或者目标函数是不是public,只要在第58行中(ClientDefinedProcedure(i.Name);)用对参数即可

在类B中,第75行(vvCallBack procedure01 = new vvCallBack(PrintSearchResult);)把目标函数填入新建的delegate对象中,准备输入其他类中调用.

在第81行(lst.SearchData("Red", procedure01);)进行调用,由此,类B(MainClass)的PrintSearchResult函数通过delegate被类A(DataHolder)的函数调用了.

由此可见,在类B中,要使类A的成员返调类B的函数时,需要使用delegate.

总结一下使用delegate的步骤:

1. delegate在使用前一定要先定义好,而且此定义必须要让类A和类B都能可见
2. delegate定义时的参数要和目标函数的参数保持一致
3. 需要的话,在调用类A中可以把此delegate对象当作参数,以备回调用
4. 在要调用目标函数前,必须先声明一个delegate实例,即把目标函数填入此delegate对象中,基本语法:vvCallBack newDeleInstance = new vvCallBack(TargetFunctionNameWithoutParameter);
5. 把此delegate实例当作参数,被类A的函数调用;此delegate也可以直接执行,如文末的例子一样,就用 newdeleInstance.Invoke();

DELPHI开发调用WEBSERVICE的一个简单例子,先转帖过来,代码还没有验证其正确性
原帖地址: http://kb.cnblogs.com/a/1505053/

========================================================

Webservice技术的出现将各种开发技术和语言完全的融合了，下面就这种融合在C#和delphi之间的交互做一次全面的体现

1.使用C#创建一个Webservice服务。
使用vs2005的模板创建C#的webservice非常容易。原文件如下:
[WebService(Namespace = "http://localhost/webserver/")]
[WebServiceBinding(ConformsTo = WsiProfiles.BasicProfile1_1)]

public class Service : System.Web.Services.WebService
{
public Service () {
//如果使用设计的组件，请取消注释以下行
InitializeComponent();
}

#region Component Designer generated code
private void InitializeComponent()
{

}
//Web 服务设计器所必需的
private IContainer components = null;

protected override void Dispose(bool disposing)
{
if (disposing && components != null)
{
components.Dispose();
}
base.Dispose(disposing);
}
#endregion
//这个是自动生成的一个webservice函数，可以不要。
[WebMethod]
public string HelloWorld() {
return "Hello World";
}
//这个才是我们自己创建的，
[WebMethod]
public int addnumber(int a, int b)
{
return = a + b;
}
}
2.使用delphi创建一个dll(非com的dll)，该dll调用上面的webserivce服务。
使用delphi调用C#的webservice过程也很容易，但是对于新手可能比较麻烦(我就是这么过来的)
第一步:创建一个dll单元：
{$R *.res}
function GetNum(a,b:integer):integer stdcall; [Page]
var
ireturn :Integer;
begin
ireturn:=GetServiceSoap().addnumber(a,b); //这个GetServiceSoap是什么，看后面...
result:=ireturn;
end;
exports
GetNum name ’GetNum’;

begin
end.
//如果是delphi调用该dll必须使用下面的代码。C#调用则不需要了(C#还是要牛一些，呵呵)
initialization
coinitialize(nil);
finalization
counInitializ
第二步:将webserivce的WSDL导入到该dll工程中，如何导，方法至少有两种，我说简单的一种:
file->new->other->WebService->WSDL Importer，(将C#的WSDL输入)然后delphi会自动给你生成了一个pas文件，
function GetServiceSoap(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): ServiceSoap;
const
defWSDL = ’http://localhost/webserver/Service.asmx?WSDL’;
defURL = ’http://localhost/webserver/Service.asmx’;
defSvc = ’Service’;
defPrt = ’ServiceSoap’;
var
RIO: THTTPRIO;
begin
Result := nil;
if (Addr = ’’) then
begin
if UseWSDL then
Addr := defWSDL
else
Addr := defURL;
end;
if HTTPRIO = nil then
RIO := THTTPRIO.Create(nil)
else
RIO := HTTPRIO;
try
//RIO.HTTPWebNode.UseUTF8InHeader:=True; //在此添加一句，修改编码方案。
Result := (RIO as ServiceSoap);
if UseWSDL then
begin
RIO.WSDLLocation := Addr;
RIO.Service := defSvc;

RIO.Port := defPrt;
end else
RIO.URL := Addr;
finally
if (Result = nil) and (HTTPRIO = nil) then
RIO.Free;
end;
end;

initialization
InvRegistry.RegisterInterface(TypeInfo(ServiceSoap), ’http://localhost/webserver/’, ’utf-8’); [Page]
InvRegistry.RegisterDefaultSOAPAction(TypeInfo(ServiceSoap), ’http://localhost/webserver/%operationName%’);
//对于无法识别传入的参数的问题，需要手工加上这一句>......
InvRegistry.RegisterInvokeOptions(TypeInfo(ServiceSoap), ioDocument);

这段代码基本上你不用关心，但是，有两个地方需要特别注意:
1.RIO.HTTPWebNode.UseUTF8InHeader:=True;对于中文参数必须加上
2.InvRegistry.RegisterInvokeOptions(TypeInfo(ServiceSoap), ioDocument);
如果传入的参数不能被webservice识别时，多半是因为你没有加上这一句。

3.使用delphi调用上面的dll
就一个函数,没有什么好说的:
procedure TForm1.Button1Click(Sender: TObject);
type
GetNumTotal=function(a,b:integer):integer;stdcall;
var
Th:Thandle;
Tf:GetNumTotal;
Tp:TFarProc;
begin
Th:=LoadLibrary(’mywebservice.dll’); {装载DLL}
if Th>0 then
try
Tp:=GetProcAddress(Th,PChar(’GetNum’));
if Tp<>nil
then begin
Tf:=GetNumTotal(Tp);
Edit1.Text:=IntToStr(Tf(1,3)); {调用GetNumTotal函数}
end
else
ShowMessage(’GetNumTotal函数没有找到’);
finally
FreeLibrary(Th); {释放DLL}
end
else
ShowMessage(’mywebservice.dll没有找到’);
end;

4.使用C#调用上面的dll

[DllImport("mywebservice.dll", EntryPoint = "GetNum")]
public static extern int GetNum(int a, int b);
private void button1_Click(object sender, EventArgs e)
{
int a,b,i;
a=10;
b =20;
i=GetNum(a,b); //第一次比较慢(webserivce的唯一弊端！！！！)
textBox1.Text = i.ToString();
}

C#中每个类都可以独立存为XML并从对应XML文件中读取. 具体操作如下:

1. 每个类的声明之前,要加XmlRoot()声明XML文件的根节点,比如:

2. 对于每一个类的公共成员,要加上如下声明:

3. 如果此公共成员是复杂类型,比如说是一个数组集合,则用XmlArray声明:

但是要注意的是多维数组无法序列化，在此情况下，只能先用个内部变量List<>来对[,]进行转化以便进行存取。

4. 如果此公共成员是另一个类,则声明如下:

5. 如果此公共成员不需要保存到XML文件,则声明如下:

6. 保存操作:

7. 读取操作: