C#指针使用简析

C#指针的存在状况简析：指针在C\C++里面可是一个好东西，但是到java，.net的时代指针已经被封装起来，对用户不可见，这点java做的非常的彻底。.net可能因为还存在一个托管C＋＋，因此指针并没有完全废除，C＃还是保留了指针的操作。

要使用指针首先要对使用指针的代码用unsafe进行进行声明，声明和public声明一样，可以对整个类进行声明，也可以是类里面某个方法或者属性。在代码里什么后，还需要修改工程项目的Build属性，让编译器支持指针的操作。

做好事前的工作就可以使用指针了。指针的使用方法和C++下使用没有太多差别。只要编译器不报错就没有太大问题。

下面就C#指针来看其他指针的一些使用上的理解：

1． 指针类型可以是实体变量（int，double）也可以是enum，同时也支持结构体变量struct。但不能是类。不过空指针可以指向类，只不过空指针不能进行任何操作，也只能把空指针作为传递对象来使用。

2． C#提供一个的关键字stackalloc用于申请堆栈内存。注意，这个申请内存分配的是栈内存，当函数执行完毕后，内存会被自动回收。不过我想用这个栈内存基本可以解决40％的问题，而且使用的时候不必担心内存泄漏问题。

3． .net 好像不直接支持堆内存的申请（这个对.net来说很危险），不过我们可以通过调用win32 api 的方法进行申请。这样就可以解决剩下40%的问题。堆内存申请的方法在MSDN里面有相关的文档，具体实现代码见附。

4．  结构体是一个特殊的对象。他与类的定义就差一个关键字，使用方法也和类一样，可以定义属性，可以定义方法。但是在进行指针操作的时候双方就有很大的差别了。结构体可以通过sizeof()取得大小，大小与结构体里有多少实体变量有关，但是如果struck里定义了类的对象，或者指针，sizeof可能会编译不过（void* 的空指针例外，不过需要在结构体声明处加上unsafe）。

5． fixed关键字：目前了解的不多，不过有一个很实用的例子可以让指针能够和.net里的数组进行交互操作： 

 
 
 
    
  
  
  
  1. byte[] buffer = new byte[100];  
    2. 
  
  
  
  2. fixed (byte* p = buffer)  
    3. 
  
  
  
  3. {  
    4. 
  
  
  
  4.     P[0] = 123;  
    5. 
  
  
  
  5.     ……  
    6. 
  
  
  
  6. } 
    7.

附C#指针的实现：

 
 
 
    
  
  
  
  1. public unsafe class Memory  
    2. 
  
  
  
  2.     {  
    3. 
  
  
  
  3. // Handle for the process heap.  
    4. 
  
  
  
  4. // This handle is used in all calls to the  
    5. 
  
  
  
  5. // HeapXXX APIs in the methods below.  
    6. 
  
  
  
  6. static int ph = GetProcessHeap();  
    7. 
  
  
  
  7. // Private instance constructor to prevent instantiation.  
    8. 
  
  
  
  8. private Memory() { }  
    9. 
  
  
  
  9. // Allocates a memory block of the given size.   
    10. 
  
  
  
  10. //The allocated memory is  
    11. 
  
  
  
  11. // automatically initialized to zero.  
    12. 
  
  
  
  12. public static void* Alloc(int size)  
    13. 
  
  
  
  13. {  
    14. 
  
  
  
  14.     void* result = HeapAlloc(ph, HEAP_ZERO_MEMORY, size);  
    15. 
  
  
  
  15.     if (result == null) throw new OutOfMemoryException();  
    16. 
  
  
  
  16.     return result;  
    17. 
  
  
  
  17. }  
    18. 
  
  
  
  18. // Copies count bytes from src to dst.   
    19. 
  
  
  
  19. //The source and destination  
    20. 
  
  
  
  20. // blocks are permitted to overlap.  
    21. 
  
  
  
  21. public static void Copy(void* src, void* dst, int count)  
    22. 
  
  
  
  22. {  
    23. 
  
  
  
  23.     byte* ps = (byte*)src;  
    24. 
  
  
  
  24.     byte* pd = (byte*)dst;  
    25. 
  
  
  
  25.     if (ps > pd)  
    26. 
  
  
  
  26.     {  
    27. 
  
  
  
  27. for (; count != 0; count--) *pd++ = *ps++;  
    28. 
  
  
  
  28.     }  
    29. 
  
  
  
  29.     else if (ps < pd)  
    30. 
  
  
  
  30.     {  
    31. 
  
  
  
  31. for (ps += count, pd += count;   
    32. 
  
  
  
  32. count != 0; count--) *--pd = *--ps;  
    33. 
  
  
  
  33.     }  
    34. 
  
  
  
  34. }  
    35. 
  
  
  
  35. // Frees a memory block.  
    36. 
  
  
  
  36. public static void Free(void* block)  
    37. 
  
  
  
  37. {  
    38. 
  
  
  
  38.     if (!HeapFree(ph, 0, block))   
    39. 
  
  
  
  39. throw new InvalidOperationException();  
    40. 
  
  
  
  40. }  
    41. 
  
  
  
  41. // Re-allocates a memory block.   
    42. 
  
  
  
  42. //If the reallocation request is for a  
    43. 
  
  
  
  43. // larger size, the additional region of memory is automatically  
    44. 
  
  
  
  44. // initialized to zero.  
    45. 
  
  
  
  45. public static void* ReAlloc(void* block, int size)  
    46. 
  
  
  
  46. {  
    47. 
  
  
  
  47.     void* result = HeapReAlloc(ph, HEAP_ZERO_MEMORY, block, size);  
    48. 
  
  
  
  48.     if (result == null) throw new OutOfMemoryException();  
    49. 
  
  
  
  49.     return result;  
    50. 
  
  
  
  50. }  
    51. 
  
  
  
  51. // Returns the size of a memory block.  
    52. 
  
  
  
  52. public static int SizeOf(void* block)  
    53. 
  
  
  
  53. {  
    54. 
  
  
  
  54.     int result = HeapSize(ph, 0, block);  
    55. 
  
  
  
  55.     if (result == -1) throw new InvalidOperationException();  
    56. 
  
  
  
  56.     return result;  
    57. 
  
  
  
  57. }  
    58. 
  
  
  
  58. // Heap API flags  
    59. 
  
  
  
  59. const int HEAP_ZERO_MEMORY = 0x00000008;  
    60. 
  
  
  
  60. // Heap API functions  
    61. 
  
  
  
  61. [DllImport("kernel32")]  
    62. 
  
  
  
  62. static extern int GetProcessHeap();  
    63. 
  
  
  
  63. [DllImport("kernel32")]  
    64. 
  
  
  
  64. static extern void* HeapAlloc(int hHeap, int flags, int size);  
    65. 
  
  
  
  65. [DllImport("kernel32")]  
    66. 
  
  
  
  66. static extern bool HeapFree(int hHeap, int flags, void* block);  
    67. 
  
  
  
  67. [DllImport("kernel32")]  
    68. 
  
  
  
  68. static extern void* HeapReAlloc(int hHeap, int flags,  
    69. 
  
  
  
  69.    void* block, int size);  
    70. 
  
  
  
  70. [DllImport("kernel32")]  
    71. 
  
  
  
  71. static extern int HeapSize(int hHeap, int flags, void* block);  
    72. 
  
  
  
  72.     } 
    73.

C#指针方面的内容就向你介绍到这里，希望对你了解学习C#指针有所帮助。

当前文章：C#指针使用简析
链接分享：http://www.shufengxianlan.com/qtweb/news22/343922.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

电子商务知识

同城分类信息

成都木托盘　　 　网站建设方案　　 　网站空间　　 　升施印刷　　 　成都花箱厂家　　 　等级保护测评　　 　IOS开发　　 　电商网站建设　　 　微信小程序开发　　 　app开发　　 　川银永信　　 　网站空间　　 　免备案虚拟主机　　 　成都小程序定制开发公司　　 　成都未宇聚　　 　棕树数据中心　　 　企业网站设计　　 　B2C电商系统　　 　柔性防护网　　 　手机网站制作