C# 指针之美

分手后的思念是犯贱 2022-07-16 05:13 153阅读 0赞

[C\# 指针之美][C_]

将C\#图像库的基础部分开源了（[https://github.com/xiaotie/GebImage][https_github.com_xiaotie_GebImage]）。这个库比较简单，且离成熟还有一段距离，但它是一种新的开发模式的探索：以指针和非托管内存为主的C\#程序开发。  
    我许多项目都是在这个库基础上的开发，实战证明了它的有效。从今天起，将断断续续（太忙了）的写一系列文章来介绍这种开发方法，介绍基于此的图像编程。本文便是第一篇。  
    以指针和非托管内存为主的C\#程序开发，无论对.Net程序员来说，还是对传统的C/C++程序员来说，均属异类。然而这种方法在很多场景下是非常有效的，尤其是图像编程，所谓谈笑间，樯橹灰飞烟灭，不外如是。  
    既有C/C++的高性能，又能直接管理内存不给GC带来压力，同时又拥有.net开发的大部分优势，可以快速迭代，何乐而不为呢？

## 一、简洁优美的代码 ##

本来初稿这节写了好几百字，将C\#指针开发与C/C++开发，Java开发、D语言开发等进行对比，阐述理念。不过现在觉得，阐述一个新事物，没有比用例子更直接的了。  
    例子：打开一张图像，先将它转化为灰度图像，再进行二值化（变成黑白图像），然后进行染色，将白色的像素变成红色。以上每一个过程都弹出窗体显示出来。  
    代码截图更有视觉冲击力：

![gebimage_demo.jpg][]

像诗歌一样简洁和优美，这就是孤的代码。具备C/C++的高性能和C\#的行云流水，同时又有IDE的强大生产力相助，说这些话已属多余，看见这样的代码，更应该想到的是：妹纸，今天工作全部搞定，现在有空吗，哥来接你。  
    这才是工作，这才是生活。留下时间，看看书，看看漫画，玩玩乐乐。最近在看《偷星九月天》，就拿沧殿来测试这段程序吧：

![demo_nov.jpg][]

改编    程序员A：那帮孙子又新提了几百条需求，老大，你要带我们突围吗？  
    程序员B：不是突围，是杀光它们！

下面，请跟随我，来一段短程探险吧。  
     （本文中的代码可在 [ https://github.com/xiaotie/GebImage/tree/develop][https_github.com_xiaotie_GebImage_tree_develop] 处下载。打包下载地址见 [ 集异璧图像与视觉分析库][Link 1] ）

## 二、C\# 指针基础 ##

在C\#中使用指针，需要在项目属性中选中“Allow unsafe code”：

![unsafe.jpg][]

接着，还需要在使用指针的代码的上下文中使用unsafe关键字，表明这是一段unsafe代码。  
    可以用unsafe \{  \} 将代码围住，如：

![复制代码][copycode.gif]

unsafe  
                     \{  
                          new ImageArgb32(path).ShowDialog( " 原始图像 ")  
                             .ToGrayscaleImage().ShowDialog( " 灰度图像 ")  
                             .ApplyOtsuThreshold().ShowDialog( " 二值化图像 ")  
                             .ToImageArgb32()  
                             .ForEach((Argb32\* p) => \{  if (p->Red ==  255) \*p = Argb32.RED; \})  
                             .ShowDialog( " 染色 ");  
                     \}

![复制代码][copycode.gif]

也可在方法或属性上加入unsafe关键字，如：

private  unsafe  void btnSubmit\_Click( object sender, EventArgs e)

也可在class或struct 上加上unsafe 关键字，如：

public  partial  unsafe  class FrmDemo1 : Form

指针配合fixed关键字可以操作托管堆上的值类型，如：

![复制代码][copycode.gif]

public  unsafe  class Person  
    \{  
         public  int Age;  
  
         public  void SetAge( int age)  
        \{  
             fixed ( int\* p = &Age)  
            \{  
                \*p = age;  
            \}  
        \}  
    \}

![复制代码][copycode.gif]

指针可以操作栈上的值类型，如：

int age =  0;  
              int\* p = &age;  
             \*p =  20;  
             MessageBox.Show(p->ToString());

指针也可以操作非托管堆上的内存，如：

IntPtr handle = System.Runtime.InteropServices.Marshal.AllocHGlobal( 4);  
             Int32\* p = (Int32\*)handle;  
             \*p =  20;  
             MessageBox.Show(p->ToString());  
             System.Runtime.InteropServices.Marshal.FreeHGlobal(handle);

System.Runtime.InteropServices.Marshal.AllocHGlobal 用来从非托管堆上分配内存。System.Runtime.InteropServices.Marshal.FreeHGlobal(handle)用来释放从非托管对上分配的内存。这样我们就可以避开GC，自己管理内存了。

## 三、几种常用用法 ##

1、使用Dispose模式管理非托管内存

如果使用非托管内存，建议用Dispose模式来管理内存，这样做有以下好处： 可以手动dispose来释放内存；可以使用using 关键字开管理内存；即使不释放，当Dispose对象被GC回收时，也会收回内存。

下面是Dispose模式的简单例子：

![ContractedBlock.gif][] ![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

1          public  unsafe  class UnmanagedMemory : IDisposable  
 2         \{  
 3              public  int Count \{  get;  private  set; \}  
 4   
 5              private  byte\* Handle;  
 6              private  bool \_disposed =  false;  
 7   
 8              public UnmanagedMemory( int bytes)  
 9             \{  
10                 Handle = ( byte\*) System.Runtime.InteropServices.Marshal.AllocHGlobal(bytes);  
11                 Count = bytes;  
12             \}  
13   
14              public  void Dispose()  
15             \{  
16                 Dispose( true);  
17                 GC.SuppressFinalize( true);  
18             \}  
19   
20              protected  virtual  void Dispose(  bool isDisposing )  
21             \{  
22                  if (\_disposed)  return;  
23                  if (isDisposing)  
24                 \{  
25                      if (Handle !=  null)  
26                     \{  
27                         System.Runtime.InteropServices.Marshal.FreeHGlobal((IntPtr)Handle);  
28                     \}  
29                 \}  
30                 \_disposed =  true;  
31             \}  
32   
33             ~UnmanagedMemory()  
34  　         \{  
35  　　           Dispose(  false );  
36  　         \}  
37         \}

![复制代码][copycode.gif]

使用：

![复制代码][copycode.gif]

using (UnmanagedMemory memory =  new UnmanagedMemory( 10))  
            \{  
                 int\* p = ( int\*)memory.Handle;  
                \*p =  20;  
                MessageBox.Show(p->ToString());  
            \}

![复制代码][copycode.gif]

2、使用 stackalloc 在栈中分配内存  
    C\# 提供了stackalloc 关键字可以直接在栈中分配内存，一般情况下，使用栈内存会比使用堆内存速度快，且栈内存不用担心内存泄漏。下面是例子：

![复制代码][copycode.gif]

int\* p =  stackalloc  int\[ 10\];  
              for ( int i =  0; i <  10; i++)  
             \{  
                 p\[i\] =  2 \* i +  2;  
             \}  
             MessageBox.Show(p\[ 9\].ToString());

![复制代码][copycode.gif]

3、模拟C中的union（联合体）类型  
     使用 StructLayout 可以模拟C中的union：

![复制代码][copycode.gif]

\[StructLayout(LayoutKind.Explicit)\]  
         public  struct Argb32  
        \{  
            \[FieldOffset( 0)\]  
             public Byte Blue;  
            \[FieldOffset( 1)\]  
             public Byte Green;  
            \[FieldOffset( 2)\]  
             public Byte Red;  
            \[FieldOffset( 3)\]  
             public Byte Alpha;  
  
            \[FieldOffset( 0)\]  
             public Int32 IntVal;  
        \}

![复制代码][copycode.gif]

这个和指针无关，非unsafe环境下也可使用，有很多用途，比如，序列化和反序列化，求hash值 ……

## 四、C\# 指针操作的几个缺点 ##

C\# 指针操作的缺点也不少。下面一一道来。  
    缺点1：只能用来操作值类型  
    .Net中，引用类型的内存管理全部是由GC代劳，无法取得其地址，因此，无法用指针来操作引用类型。所以，C\#中指针操作受到值类型的限制，其中，最主要的一点就是：值类型无法继承。  
    这一点看起来是致命的，其实不然。首先，需要用到指针来提高性能的地方，其类型是很少变动的。其次，在OO编程中有个名言：组合优于继承。使用组合，我们可以解决很多需要继承的地方。第三，最后，我们还可以使用引用类型来对值类型打包，进行继承，权衡两者的比重来完成任务。  
    缺点2：泛型不支持指针类型  
    C\# 中泛型不支持指针类型。这是个很大的限制，在后面的篇幅中，我会引入模板机制来克服这个问题。同理，迭代器也不支持指针，因此，我们需要自己实现迭代机制。  
    缺点3：没有函数指针  
    幸运的是，C\# 中有delegate，delegate 支持支持指针类型，lambda 表达式也支持指针。后面会详细讲解。

## 五、引入模板机制 ##

没有泛型，但是我们可以模拟出一套类似C++的模板机制出来，进行代码复用。这里大量的用到了C\#的语法糖和IDE的支持。  
    先介绍原理：  
    partial 关键字让我们可以将一个类的代码分在多个文件，那么可以这样分：第一个文件是我们自己写的代码，第二个文件用来描述模板，第三个文件，用来根据模板自动生成代码。  
    三个文件这样取名字的：

![gebimage_demo2.jpg][]

XXXClassHelper 是模板定义文件，XXXClassHelper\_Csmacro.cs 是自动生成的模板实现代码。

ClassHelper文件的例子：

![复制代码][copycode.gif]

namespace Geb.Image  
\{  
     using TPixel = Argb32;  
     using TCache = System.Int32;  
     using TKernel = System.Int32;  
     using TImage = Geb.Image.ImageArgb32;  
     using TChannel = System.Byte;  
  
     public  static  partial  class ImageArgb32ClassHelper  
    \{  
         \#region include "ImageClassHelper\_Template.cs"  
         \#endregion  
    \}  
  
     public  partial  class ImageArgb32  
    \{  
         \#region include "Image\_Template.cs"  
         \#endregion  
  
         \#region include "Image\_Paramid\_Argb\_Templete.cs"  
         \#endregion  
    \}  
  
     public  partial  struct Argb32  
    \{  
         \#region include "TPixel\_Template.cs"  
         \#endregion  
    \}  
\}

![复制代码][copycode.gif]

这里用到了using 语法糖。using 关键字，可以为一个类型取别名。使用 VS 的 \#region 来定义所使用的模板文件的位置。上面这个文件中，引用了4个模板文件：ImageClassHelper\_Template.cs，Image\_Template.cs，Image\_Paramid\_Argb\_Templete.cs 和 TPixel\_Template.cs。  
    只看其中的一个模板文件  Image\_Template.cs：

![复制代码][copycode.gif]

using TPixel = System.Byte;  
  using TCache = System.Int32;  
  using TKernel = System.Int32;  
   
  using System;  
  using System.Collections.Generic;  
  using System.Text;  
   
  namespace Geb.Image.Hidden  
 \{  
      public  abstract  class Image\_Template : UnmanagedImage<TPixel>  
     \{  
          private Image\_Template()  
             :  base( 1, 1)  
         \{  
              throw  new NotImplementedException();  
         \}  
   
          \#region mixin  
   
          public  unsafe TPixel\* Start \{  get \{  return (TPixel\*) this.StartIntPtr; \} \}  
   
          public  unsafe TPixel  this\[ int index\]  
         \{  
              get  
             \{  
                  return Start\[index\];  
             \}  
              set  
             \{  
                 Start\[index\] = value;  
             \}  
         \}  
   
     
   ……  
   
   
          \#endregion  
     \}  
 \}

![复制代码][copycode.gif]

这个模板文件是编译通过的。也使用了 using 关键字来对使用的类型取别名，同时，在代码中，有一段用 \#region mixin 和 \#endregion 环绕的代码。只需要写一个工具，将模板文件中 \#region mixin 和 \#endregion 环绕的代码提取出来，替换到模板定义中 \#region include "Image\_Template.cs" 和 \#endregion 之间，生成第三个文件 ClassHelper\_Csmacro.cs 即可实现模板机制。由于都使用了 using 关键字对类型取别名，因此，ClassHelper\_Csmacro.cs 文件也是可以编译通过的。在不同的模板定义中，令同样的符号来代表不同的类型，实现了模板代码的公用。  
    上面机制可以全部自动化。Csmacro 是我写的一个工具，可以完成上面的过程。将它放在系统路径下，然后在项目的build event中添加pre-build 指令即可。Csmacro 程序在代码包的lib的目录下。

![csmacro_prebuild.jpg][]

如此实装，我们就有模板用了！一切自动化，就好像内置的一样。强类型、有编译器进行类型约束，减少出错的可能。调试也很容易，就和调试普通的C\#代码一样，不存在C++中的模板的难调试问题。缺点嘛，就是没有C++中模板的语法优美，但是，也看的过去，至少比C中的宏好看多了是吧。  
    参照上面对模板的实现，完全可以定义出一套C\#的宏出来。没这样做，是因为没这个需求。

下面是一个完整的例子，为 Person 类和 Cat 类添加模板扩展方法（非扩展方法也可类似添加），由于这个方法有指针，无法用泛型实现：

void SetAge( this T item,   int\* age)

首先，建一个可编译通过的模板类 Template.cs：

![复制代码][copycode.gif]

namespace Introduce.Hide  
 \{  
      using T = Person;  
   
      public  static  class Template  
     \{  
          \#region mixin  
   
          public  static  unsafe  void SetAge( this T item,   int\* age)  
         \{  
             item.Age = \*age;  
         \}  
   
          \#endregion  
     \}  
 \}

![复制代码][copycode.gif]

我在命名空间中加入了 Hide，只要不引用这个命名空间，这个扩展方法不会出现对程序产生干扰。  
    接着，建立 PersonClassHelper.cs 文件：

![复制代码][copycode.gif]

namespace Introduce  
 \{  
      using T = Person;  
   
      public  static  partial  class PersonClassHelper  
     \{  
          \#region include "Template.cs"  
          \#endregion   
     \}  
 \}

![复制代码][copycode.gif]

建立 CatClassHelper.cs 文件：

![复制代码][copycode.gif]

namespace Introduce  
 \{  
      using T = Cat;  
   
      public  static  partial  class CatClassHelper  
     \{  
          \#region include "Template.cs"  
          \#endregion  
     \}  
 \}

![复制代码][copycode.gif]

为了节省篇幅，我省略了命名空间的引用，实际代码中是有命名空间的引用的。下载包里包含了全部的代码。  
    接下来，编译一下，哈哈，编译通过。  
    且慢，怎么看不到编译生成的两个 Csmacro.cs 文件呢？

这两个文件已经生成了，需要手动将它们添加到项目中，只用添加一次即可。添加进来，再编译一下，哈哈，通过。  
    这个例子虽小，可不要小看模板啊，在Geb.Image库里，大量使用了模板：

![gebimage_demo3.jpg][]

有了模板，只用维护公共代码。

## 六、迭代器 ##

下面来实现迭代器。这里，要放弃使用foreach，返回古老的迭代器模式，来访问图像的每一个像素：

![复制代码][copycode.gif]

public  unsafe  struct ItArgb32Old  
    \{  
         public  unsafe Argb32\* Current;  
         public  unsafe Argb32\* End;  
  
         public  unsafe Argb32\* Next()  
        \{  
             if (Current < End)  return Current ++;  
             else  return  null;  
        \}  
    \}  
  
     public  static  class ImageArgb32Helper  
    \{  
         public  unsafe  static ItArgb32Old CreateItorOld( this ImageArgb32 img)  
        \{  
            ItArgb32Old itor =  new ItArgb32Old();  
            itor.Current = img.Start;  
            itor.End = img.Start + img.Length;  
             return itor;  
        \}  
    \}

![复制代码][copycode.gif]

不幸的是，测试性能，这个迭代器比单纯的while循环慢很多。对一个100万像素的图像，将其每一个像素值的Red分量设为200，循环100遍，使用迭代器在我的电脑上耗时242 ms，直接使用循环耗时 72 ms。我测试了很多种方案，均未得到和直接循环性能近似的迭代器实现方案。

没有办法，只好对迭代器来打折了，只进行部分抽象（这已经不能算迭代器了，但这里仍沿用这个名称）：

![复制代码][copycode.gif]

public  unsafe  struct ItArgb32  
     \{  
          public  unsafe Argb32\* Start;  
          public  unsafe Argb32\* End;  
   
          public  int Step(Argb32\* ptr)  
         \{  
              return  1;  
         \}  
     \}

![复制代码][copycode.gif]

产生迭代器的代码：

![复制代码][copycode.gif]

public  unsafe  static ItArgb32 CreateItor( this ImageArgb32 img)  
     \{  
         ItArgb32 itor =  new ItArgb32();  
         itor.Start = img.Start;  
         itor.End = img.Start + img.Length;  
          return itor;  
     \}

![复制代码][copycode.gif]

使用：

ItArgb32 itor = img.CreateItor();  
      for (Argb32\* p = itor.Start; p < itor.End; p+= itor.Step(p))  
     \{  
         p->Red =  200;  
     \}

测试性能和直接循环性能几乎一样。有人可能要问，你这样有什么优势？和for循环有什么区别？  
    这个例子中当然看不出优势，换个例子就可以看出来了。  
    在图像编程中，有 ROI（Region of Interest，感兴趣区域）的概念。比如，在下面这张女王出场的画面中，假设我们只对她的头部感兴趣（ROI区域），只对该区域进行处理（标注为红色区域）。

![nov_roi.jpg][]

对ROI区域创建一个迭代器，用来迭代ROI中的每一行：

![复制代码][copycode.gif]

public  unsafe  struct ItRoiArgb32  
    \{  
         public  unsafe Argb32\* Start;  
         public  unsafe Argb32\* End;  
         public  int Width;  
         public  int RoiWidth;  
  
         public  int Step(Argb32\* ptr)  
        \{  
             return Width;  
        \}  
  
         public ItArgb32 Itor(Argb32\* p)  
        \{  
            ItArgb32 it =  new ItArgb32();  
            it.Start = p;  
            it.End = p + RoiWidth;  
             return it;  
        \}  
    \}

![复制代码][copycode.gif]

这个ROI迭代器又可以产生一个ItArgb32迭代器，来迭代该行中的像素。

产生ROI迭代器的代码如下，为了简化代码，我这里没有进行ROI的验证：

![复制代码][copycode.gif]

public  unsafe  static ItRoiArgb32 CreateRoiItor( this ImageArgb32 img,  
             int x,  int y,  int roiWidth,  int roiHeight)  
        \{  
            ItRoiArgb32 itor =  new ItRoiArgb32();  
            itor.Width = img.Width;  
            itor.RoiWidth = roiWidth;  
            itor.Start = img.Start + img.Width \* y + x;  
            itor.End = itor.Start + img.Width \* roiHeight;  
             return itor;  
        \}

![复制代码][copycode.gif]

性能测试表明，使用ROI迭代器进行迭代和直接进行循环，性能一致。  
    为一副图像添加ROI字段，设置ROI值来控制不同的处理区域，然后用ROI迭代器进行迭代，比直接使用循环要方便得多。

## 七、风情万种的Lambda表达式 ##

接下来，来看看C\#指针最有风情的一面——Lambda表达式。  
    C\# 里 delegate 支持指针，下面这种写法是没有问题的：

void ActionOnPixel(TPixel\* p);

对于图像处理，我定义了许多扩展方法，ForEach是其中的一种，下面是它的模板定义：

![复制代码][copycode.gif]

public  unsafe  static UnmanagedImage<TPixel> ForEach( this UnmanagedImage<TPixel> src, ActionOnPixel handler)  
        \{  
            TPixel\* start = (TPixel\*)src.StartIntPtr;  
            TPixel\* end = start + src.Length;  
             while (start != end)  
            \{  
                handler(start);  
                ++start;  
            \}  
             return src;  
        \}

![复制代码][copycode.gif]

让我们用lambda表达式对图像迭代，将每像素的Red分量设为200吧，一行代码搞定：

img.ForEach((Argb32\* p) => \{ p->Red =  200; \});

用ForEach测试，对100万像素的图像设置Red通道值为200，循环100次，我的测试结果是 400 ms，约是直接循环的 4-5 倍。可见这是个性能不高的操作（其实也够高了，100万象素，循环100遍，耗时400ms），可以在对性能要求不是特别高时使用。

## 八、与C/C++的比较 ##

我测试了很多场景，C\# 下指针性能约是 C/C++ 的 70-80%，性能差距，可以忽略。

相对于C/C++来说，C\#无法直接操作硬件是其遗憾，这种情况，可以使用C/C++写段小程序来弥补，不过，我还没遇到这种场景。很多情况都可以P/Invoke解决。  
    做图像的话，很多时候需要使用显卡加速，如使用CUDA或OpenCL，幸运的是，C\#也可以直接写CUDA或OpenCL代码，但是功能可能会受到所用的库的限制。也可以用传统方式写CUDA或OpenCL代码，再P/Invoke调用。如果用传统的C/C++开发的话，也需要做同样的工作。

和C比较：

这套方案比C的抽象程度高，我们有模板，有lambda表达式，还有一大票的语法糖。在类库上，比C的类库完善的多。我们还有反射，有命名空间等等一大票的东西。

和C++比较：  
    这套方案的抽象程度比C++要低一些。毕竟，值类型无法继承，模板机制比C++ 差一点。但是在生产力上比C++要高很多。抛开C++那一大票陷阱不说，以秒计算的编译速度就够让C++程序员流口水的。当我们在咖啡馆里约会喝咖啡时，C++程序员还正端着一杯咖啡坐在电脑前等待程序编译结束。

## 九、接下来的工作 ##

接下来的工作主要有两个：  
    内联工具：C\# 的内联还不够强大。需要一个内联工具，对想要内联的方法使用特性标记一下，在编译结束后，在IL代码层面内联。  
    翻译工具：移动开发是个痛。如何将C\#的代码翻译成C/C++的代码，在缺乏.Net的运行时下运行？  
  
    这两个工作都不紧要。C\#内联效果不好的地方（这种情况很少），可以手动内联。至于移动开发嘛，在哥的一云三端大计中，C\# 的定位是云图像开发（C\#+CUDA），三端中，桌面运用是用C\#和Flash开发，Web和移动应用使用Flash开发，没有C\#的事情。

C/C++ 呢？更没有它们的位置啦！不对，还是有的。用它们来开发Flash应用的核心算法！够另类吧！

作者： [xiaotie][] , [ 集异璧实验室(GEBLAB)][_GEBLAB]

出处： [http://www.cnblogs.com/xiaotie/][xiaotie]

若标题中有“转载”字样，则本文版权归原作者所有。若无转载字样，本文版权归作者和博客园共有，欢迎转载，但未经作者同意必须保留此段声明，且在文章页面明显位置给出原文连接，否则保留追究法律责任的权利.

分类: [ \[10\]图像处理][_10], [\[21\]编码艺术][21]

好文要顶 关注我  收藏该文 ![icon_weibo_24.png][] ![wechat.png][]

[![u6006.jpg][]][u6006.jpg 1]

[xiaotie][u6006.jpg 1]  
[关注 - 44][- 44]  
[粉丝 - 2070][- 2070]

荣誉： [推荐博客][Link 2]

\+加关注

[« ][Link 3]上一篇： [IE9 下 Flash 显示列表中没有对象后不再显示的Bug][Link 3]  
[» ][Link 4]下一篇： [云端漫步][Link 4]

posted @ 2012-07-06 18:21 [ xiaotie][xiaotie] 阅读( 30715) 评论( 82) [ 编辑][Link 5] [ 收藏][Link 6]

[< Prev][Prev] [1][Prev] 2

评论列表

[\#51楼][51]  2012-07-10 17:35 [ 逆时针の风][Link 7] [  ][Link 8]

真的很牛

支持(0) 反对(0)

http://pic.cnblogs.com/face/u132191.jpg

[\#52楼][52]  2012-07-11 10:08 [ artwl][artwl] [  ][Link 9]

铁哥很博学，很强大

支持(0) 反对(0)

http://pic.cnblogs.com/face/u112805.png?id=201209274142

[\#53楼][53]  2012-07-11 15:30 [ yetta2011][yetta2011] [  ][Link 10]

好详细啊，真是很不错！C\#，\[url= [http://www.lirenedu.org/][http_www.lirenedu.org]\]C语言都是基础。楼主能分享这么详细的基础知识真是很不错。

支持(0) 反对(0)

[\#54楼][54]  2012-07-14 09:52 [ Florian][Florian] [  ][Link 11]

[@][Link 12] xiaotie  
栈内存和的堆内存的速度怎么比较呢？同样是内存，只是分布在内存空间的不同位置罢了，内存访问的速度是一样的，由硬件决定。唯一区别的是栈内存分配只需要将栈指针esp修改即可，堆分配需要执行堆分配算法，修改“空表”等相关数据结构，因此相对耗时。如果一定要区别他们的速度的话，只能说栈分配算法比堆分配算法速度快了。

支持(0) 反对(0)

http://pic.cnblogs.com/face/405877/20160812025610.png

[\#55楼][55] \[ 楼主\] 2012-07-14 16:12 [ xiaotie][xiaotie] [  ][Link 13]

[@][54] Florian  
栈内存比堆内存从缓存角度来看，性能要好一点。这是一个古老的测试 [ http://citeseerx.ist.psu.edu/viewdoc/summary?doi][http_citeseerx.ist.psu.edu_viewdoc_summary_doi]=10.1.1.48.3778 当然现在高速缓存都大了，差别一般情况看不出。

支持(0) 反对(0)

/images/20220716/6b4282c2776b40519b6211e88eb99780.png

[\#56楼][56]  2012-07-17 14:23 [ TW－刘夏][TW] [  ][Link 14]

UnmanagedMemory 的 Dispose(bool) 的实现是错误的。应该在 Dispose(false)的时候仅仅释放非托管内存。  
Dispose(bool disposing) \{  
if (this.disposed) return;  
if (disposing) \{ ReleaseManagedObjects(); \}  
ReleaseUnmanagedObjects();  
this.disposed = true;  
\}

支持(0) 反对(0)

http://pic.cnblogs.com/face/u33500.jpg?id=08093440

[\#57楼][57]  2012-07-17 16:02 [ jone\_e][jone_e] [  ][Link 15]

[@][Link 16] iMetro  
内裤套在头上就强大？这是什么逻辑。。

支持(0) 反对(0)

http://pic.cnblogs.com/face/u368927.jpg?id=03175354

[\#58楼][58] \[ 楼主\] 2012-07-18 01:59 [ xiaotie][xiaotie] [  ][Link 13]

[@][56] 夏天可是个好季节  
[引用][56] UnmanagedMemory 的 Dispose(bool) 的实现是错误的。应该在 Dispose(false)的时候仅仅释放非托管内存。  
Dispose(bool disposing) \{  
if (this.disposed) return;  
if (disposing) \{ ReleaseManagedObjects(); \}  
ReleaseUnmanagedObjects();  
this.disposed = true;  
\}  
这里有问题，写博客时偷懒了，网上找了一个Dispose模式就用了，Geb.Image的UnmanagedImage的是正确的。谢谢指正。

支持(0) 反对(0)

/images/20220716/6b4282c2776b40519b6211e88eb99780.png

[\#59楼][59]  2012-07-18 12:01 [ WebAPI][WebAPI] [  ][Link 17]

西安Asp.Net技术交流群：16439504  
只限西安地区，主要交流html、css、js、ajax、jQuery、Asp.Net、Linq、MVC、SQL、IIS等web开发相关技术，欢迎大家加群，非技术人员请勿进群，谢谢合作！！！

支持(0) 反对(0)

http://pic.cnblogs.com/face/318306/20150318162101.png

[\#60楼][60]  2012-07-19 11:49 [ Matthew Lee][Matthew Lee] [  ][Link 18]

要我说，没看到什么优美的地方，只看到一个自大的C\#程序员罢了

支持(2) 反对(0)

[\#61楼][61]  2012-08-02 23:00 [ xiaxia—博客园][xiaxia] [  ][Link 19]

c\# 图形开发我用的是AForge和EmguCV.  
AForge是纯C\#的,Emgucv是对opencv的封装和扩充.  
通过学习EmguCV的源码风格和调用c动态链接库的操作代码,学习到很多c\#用指针的知识和类库开发规范,感兴趣的朋友看这里  
[http://www.emgu.com/wiki/index.php/Main\_Page][http_www.emgu.com_wiki_index.php_Main_Page]

支持(0) 反对(0)

http://pic.cnblogs.com/face/u337335.jpg?id=01160537

[\#62楼][62]  2012-08-14 16:07 [ TFS][TFS] [  ][Link 20]

[@][60] Matthew Lee  
你为啥要这样说那，我认为很不错啊！

支持(0) 反对(1)

http://pic.cnblogs.com/face/u46477.jpg?id=20131658

[\#63楼][63]  2012-08-17 14:31 [ 卿哥][Link 21] [  ][Link 22]

我是看楼主头像进来的......

支持(0) 反对(0)

[\#64楼][64]  2012-09-13 14:42 [ 蝗虫的大腿][Link 23] [  ][Link 24]

老大,求求你直接用C++行吗.....

支持(1) 反对(0)

http://pic.cnblogs.com/face/22572/20140108231143.png

[\#65楼][65] \[ 楼主\] 2012-09-13 15:41 [ xiaotie][xiaotie] [  ][Link 13]

[@][64] 蝗虫的大腿  
C++开发效率低好多，赚钱速度低啊

支持(0) 反对(0)

/images/20220716/6b4282c2776b40519b6211e88eb99780.png

[\#66楼][66]  2012-10-20 19:27 [ ysgepl][ysgepl] [  ][Link 25]

这不是扯淡吗，要么用c++，要么用c\# ，有必要在c\#中使用不论不类的指针吗

支持(2) 反对(0)

[\#67楼][67]  2012-10-26 17:26 [ 心电心][Link 26] [  ][Link 27]

铁哥一看就是c/c++出身啊,佩服佩服

支持(0) 反对(0)

http://pic.cnblogs.com/face/449136/20140829150219.png

[\#68楼][68]  2012-12-08 18:47 [ 夜不寂寞][Link 28] [  ][Link 29]

[@][65] xiaotie  
像个白痴一样在c\#里面使用指针，鄙视

支持(0) 反对(0)

[\#69楼][69]  2012-12-08 18:47 [ 夜不寂寞][Link 28] [  ][Link 29]

[@][66] ysgepl  
[引用][66] 这不是扯淡吗，要么用c++，要么用c\# ，有必要在c\#中使用不论不类的指针吗  
博主是白痴么

支持(0) 反对(0)

[\#70楼][70]  2012-12-31 18:30 [ 宇宙大将军][Link 30] [  ][Link 31]

[@][66] ysgepl  
博主要展现内裤套在头上的行为给我们看看。

支持(0) 反对(0)

[\#71楼][71]  2013-02-18 16:10 [ 山海雍和][Link 32] [  ][Link 33]

额，喷子太多，受不了。举个例子：我们最近做的一个项目里面GDI+需要高频率刷新，带我的那个大哥在使用指针后，速度提高十多倍。所以好多东西没见过，没用过真不敢妄加评论，感觉楼主语言造诣很高，不然就没这么深的技术文章。

支持(1) 反对(0)

http://pic.cnblogs.com/face/u374846.jpg?id=13002442

[\#72楼][72]  2013-03-11 17:25 [ 诺贝尔][Link 34] [  ][Link 35]

[@][68] 夜不寂寞  
[引用][68] @xiaotie  
像个白痴一样在c\#里面使用指针，鄙视  
  
我们是程序员，一切以解决问题为目的，指针也好，只要能解决问题，为何不用？  
  
平常人很少用到指针，但是c＃的封装太严密了，有一些操作必需要用到指针去解决。

支持(2) 反对(0)

http://pic.cnblogs.com/face/u109469.jpg

[\#73楼][73]  2013-03-26 18:04 [ denjuy][denjuy] [  ][Link 36]

楼主，我顶你，正从C\#转C++开发，想着以后再回C\#用指针写代码，哈哈～

支持(0) 反对(0)

http://pic.cnblogs.com/face/u306473.jpg?id=09211550

[\#74楼][74]  2013-03-26 18:27 [ @夜猫子][Link 37] [  ][Link 38]

不错，顶

支持(0) 反对(0)

http://pic.cnblogs.com/face/188726/20131022171921.png

[\#75楼][75]  2013-07-10 10:21 [ 深蓝医生][Link 39] [  ][Link 40]

Mark一下

支持(0) 反对(0)

http://pic.cnblogs.com/face/u114517.png?id=23112533

[\#76楼][76]  2013-12-09 04:56 [ SoarNo1][SoarNo1] [  ][Link 41]

请教一下  
\[StructLayout(LayoutKind.Explicit)\]  
你确定和指针无关。。。  
那么当该结构体  
作为指针操作的时候是不按照 \[StructLayout(LayoutKind.Explicit)\]  
的内存布局进行的喽？  
如果不按照，那么按照什么布局呢？

支持(0) 反对(0)

http://pic.cnblogs.com/face/125552/20160429020606.png

[\#77楼][77]  2014-02-08 16:20 [ Robert Hu][Robert Hu] [  ][Link 42]

全部看懂了，很是享受。铁哥厉害，很博学，对c\#和c++研究得很深。

支持(0) 反对(0)

[\#78楼][78]  2014-03-07 16:50 [ owlbcc][owlbcc] [  ][Link 43]

不感觉很乱么，本身。net就支持混合编程，c++去做c++该做的事情，c\#去做c\#该做的事情，比如我的算法完全可以用c++做dll库来进行调用！这样会不会更好些

支持(0) 反对(0)

http://pic.cnblogs.com/face/u466231.png?id=16140833

[\#79楼][79] \[ 楼主\] 2014-03-11 10:32 [ xiaotie][xiaotie] [  ][Link 13]

[@][78] owlbcc  
不会更好。C\#写算法的话，根本就没有C++的事情了，开发效率快N倍，运行效率差不多。

支持(0) 反对(0)

/images/20220716/6b4282c2776b40519b6211e88eb99780.png

[\#80楼][80]  2014-04-28 11:29 [ 叶辉][Link 44] [  ][Link 45]

每种事物的存在，都有存在的必要性。  
任何事情都有具有其两面性。  
因此要持客观的态度来对待。

支持(0) 反对(0)

http://pic.cnblogs.com/face/u29550.jpg

[\#81楼][81]  2015-07-23 15:42 [ 张静茹][Link 46] [  ][Link 47]

[@][72] 诺贝尔  
等你遇到非指针不能解决的事情,你再来谢作者,许是我水平不够,从驱动返回的VOID\*指针我在C\#里就比较难办,感谢作者给了我一线曙光

支持(0) 反对(0)

[\#82楼][82]  3393211 2016/3/28 9:24:02 2016-03-28 09:24 [ InkFx][InkFx] [  ][Link 48]

高山仰止，膜拜大神。

[C_]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html
[https_github.com_xiaotie_GebImage]: https://github.com/xiaotie/GebImage
[gebimage_demo.jpg]: /images/20220716/ac0a0118935848aa853e85b32cd508cc.png
[demo_nov.jpg]: /images/20220716/392eccb371a04ec0b89a1fd1de7bfec6.png
[https_github.com_xiaotie_GebImage_tree_develop]: https://github.com/xiaotie/GebImage/tree/develop
[Link 1]: http://www.geblab.com/?page_id=51
[unsafe.jpg]: /images/20220716/fa2f11a2b31a4e98969fb4b02390ae73.png
[copycode.gif]: /images/20220716/0095976ec1d649d7a0a77a09c9c0b329.png
[ContractedBlock.gif]: http://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif
[ExpandedBlockStart.gif]: /images/20220716/fe20657f595648b2b80744e050676ba6.png
[gebimage_demo2.jpg]: /images/20220716/72125b2f13c54ae88c21aafa567895e9.png
[csmacro_prebuild.jpg]: /images/20220716/871897b7e47c4ecfbf0c259713c881f2.png
[gebimage_demo3.jpg]: /images/20220716/4634528913334a408e14393945937109.png
[nov_roi.jpg]: /images/20220716/925c8136f79748cc9b8756e1a9af422d.png
[xiaotie]: http://www.cnblogs.com/xiaotie/
[_GEBLAB]: http://www.geblab.com/
[_10]: http://www.cnblogs.com/xiaotie/category/145078.html
[21]: http://www.cnblogs.com/xiaotie/category/39169.html
[icon_weibo_24.png]: http://common.cnblogs.com/images/icon_weibo_24.png
[wechat.png]: /images/20220716/fa08ad23b4b34dd297136eb838221858.png
[u6006.jpg]: /images/20220716/6b4282c2776b40519b6211e88eb99780.png
[u6006.jpg 1]: http://home.cnblogs.com/u/xiaotie/
[- 44]: http://home.cnblogs.com/u/xiaotie/followees
[- 2070]: http://home.cnblogs.com/u/xiaotie/followers
[Link 2]: http://www.cnblogs.com/expert/
[Link 3]: http://www.cnblogs.com/xiaotie/archive/2012/06/22/2558417.html
[Link 4]: http://www.cnblogs.com/xiaotie/archive/2012/07/20/2600883.html
[Link 5]: https://i.cnblogs.com/EditPosts.aspx?postid=2579853
[Link 6]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#
[Prev]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#!comments
[51]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2423717
[Link 7]: http://www.cnblogs.com/JimmyZheng/
[Link 8]: http://msg.cnblogs.com/send/%E9%80%86%E6%97%B6%E9%92%88%E3%81%AE%E9%A3%8E
[52]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2424089
[artwl]: http://www.cnblogs.com/artwl/
[Link 9]: http://msg.cnblogs.com/send/artwl
[53]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2424432
[yetta2011]: http://home.cnblogs.com/u/426513/
[Link 10]: http://msg.cnblogs.com/send/yetta2011
[http_www.lirenedu.org]: http://www.lirenedu.org/
[54]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2426569
[Florian]: http://www.cnblogs.com/fanzhidongyzby/
[Link 11]: http://msg.cnblogs.com/send/Florian
[Link 12]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2420992
[55]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2426729
[Link 13]: http://msg.cnblogs.com/send/xiaotie
[http_citeseerx.ist.psu.edu_viewdoc_summary_doi]: http://citeseerx.ist.psu.edu/viewdoc/summary?doi
[56]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2428308
[TW]: http://www.cnblogs.com/lxconan/
[Link 14]: http://msg.cnblogs.com/send/TW%EF%BC%8D%E5%88%98%E5%A4%8F
[57]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2428382
[jone_e]: http://www.cnblogs.com/zeq-jone/
[Link 15]: http://msg.cnblogs.com/send/jone_e
[Link 16]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2420582
[58]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2428745
[59]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2429052
[WebAPI]: http://www.cnblogs.com/webapi/
[Link 17]: http://msg.cnblogs.com/send/WebAPI
[60]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2429940
[Matthew Lee]: http://home.cnblogs.com/u/161593/
[Link 18]: http://msg.cnblogs.com/send/Matthew%20Lee
[61]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2440367
[xiaxia]: http://www.cnblogs.com/liuxia19872003/
[Link 19]: http://msg.cnblogs.com/send/xiaxia%E2%80%94%E5%8D%9A%E5%AE%A2%E5%9B%AD
[http_www.emgu.com_wiki_index.php_Main_Page]: http://www.emgu.com/wiki/index.php/Main_Page
[62]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2448360
[TFS]: http://www.cnblogs.com/yuan198094/
[Link 20]: http://msg.cnblogs.com/send/TFS
[63]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2450492
[Link 21]: http://home.cnblogs.com/u/438540/
[Link 22]: http://msg.cnblogs.com/send/%E5%8D%BF%E5%93%A5
[64]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2471982
[Link 23]: http://www.cnblogs.com/beyoung/
[Link 24]: http://msg.cnblogs.com/send/%E8%9D%97%E8%99%AB%E7%9A%84%E5%A4%A7%E8%85%BF
[65]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2472060
[66]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2497565
[ysgepl]: http://www.cnblogs.com/ysgepl/
[Link 25]: http://msg.cnblogs.com/send/ysgepl
[67]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2516689
[Link 26]: http://www.cnblogs.com/weloglog888/
[Link 27]: http://msg.cnblogs.com/send/%E5%BF%83%E7%94%B5%E5%BF%83
[68]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2573247
[Link 28]: http://home.cnblogs.com/u/477550/
[Link 29]: http://msg.cnblogs.com/send/%E5%A4%9C%E4%B8%8D%E5%AF%82%E5%AF%9E
[69]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2573248
[70]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2590321
[Link 30]: http://home.cnblogs.com/u/350750/
[Link 31]: http://msg.cnblogs.com/send/%E5%AE%87%E5%AE%99%E5%A4%A7%E5%B0%86%E5%86%9B
[71]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2618296
[Link 32]: http://www.cnblogs.com/maomiyouai/
[Link 33]: http://msg.cnblogs.com/send/%E5%B1%B1%E6%B5%B7%E9%9B%8D%E5%92%8C
[72]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2632462
[Link 34]: http://www.cnblogs.com/Nobel/
[Link 35]: http://msg.cnblogs.com/send/%E8%AF%BA%E8%B4%9D%E5%B0%94
[73]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2643226
[denjuy]: http://www.cnblogs.com/denjuy/
[Link 36]: http://msg.cnblogs.com/send/denjuy
[74]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2643239
[Link 37]: http://www.cnblogs.com/yemaozi/
[Link 38]: http://msg.cnblogs.com/send/%40%E5%A4%9C%E7%8C%AB%E5%AD%90
[75]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2723815
[Link 39]: http://www.cnblogs.com/bluedoctor/
[Link 40]: http://msg.cnblogs.com/send/%E6%B7%B1%E8%93%9D%E5%8C%BB%E7%94%9F
[76]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2832971
[SoarNo1]: http://www.cnblogs.com/SHGF/
[Link 41]: http://msg.cnblogs.com/send/SoarNo1
[77]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2871532
[Robert Hu]: http://www.cnblogs.com/Robert_Hu/
[Link 42]: http://msg.cnblogs.com/send/Robert%20Hu
[78]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2890635
[owlbcc]: http://www.cnblogs.com/lizhaoduo/
[Link 43]: http://msg.cnblogs.com/send/owlbcc
[79]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2892568
[80]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#2926824
[Link 44]: http://www.cnblogs.com/linxy/
[Link 45]: http://msg.cnblogs.com/send/%E5%8F%B6%E8%BE%89
[81]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#3233963
[Link 46]: http://home.cnblogs.com/u/641665/
[Link 47]: http://msg.cnblogs.com/send/%E5%BC%A0%E9%9D%99%E8%8C%B9
[82]: http://www.cnblogs.com/xiaotie/archive/2012/07/06/2579853.html#3393211
[InkFx]: http://www.cnblogs.com/shuxiaolong/
[Link 48]: http://msg.cnblogs.com/send/InkFx