开发者

在C#中使用指针的示例代码

开发者 https://www.devze.com 2024-10-31 10:43 出处：网络 作者： △曉風殘月〆
.Net平台定义了两种主要数据类型：值类型和引用类型，其实还有第三种数据类型：指针类型。使用指针，可以绕开CLR的内存管理机制。（说明：在C#中使用指针，需要有相关C/C++指针操作基础）
相关专题：C#使用指针C#指针C#指针操作

.Net平台定义了两种主要数据类型：值类型和引用类型，其实还有第三种数据类型：指针类型。使用指针，可以绕开CLR的内存管理机制。（说明：在C#中使用指针，需要有相关C/C++指针操作基础）

1、C#中指针相关的操作符和关键字

操作符/关键字作用
*该操作符用于创建一个指针变量，和在C/C++中一样。也可用于指针间接寻址（解除引用）
&该操作符用于获取内存中变量的地址
->该操作符用于访问一个由指针表示的类型的字段，和在C++中一样
[]在不安全的上下文中，[]操作符允许我们索引由指针变量指向的位置
++,--在不安全的上下文中，递增和递减操作符可用于指针类型
+,-在不安全的上下文中，加减操作符可用于指针类型
==, !=, <, >, <=, >=在不安全的上下文中，比较和相等操作符可用于指针类型
stackalloc在不安全的上下文中，stackalloc关键字可用于直接在栈上分配C#数组，类似CRT中的_alloca函数 
 fixed在不安全的上下文中，fixed关键字可用于临时固定一个变量以使它的地址可被找到

 2、在C#中使用指针，需要启用“允许不安全代码”设置

选择项目属性->生成，钩上“允许不安全代码”

在C#中使用指针的示例代码

3、unsafe关键字

只有在unsafe所包含的代码区块中，才能使用指针。类似lock关键字的语法结构

在C#中使用指针的示例代码

除了声明代码块为不安全代码外，也可以直接构建“不安全的”结构、类型成员和函数。

   unsafe struct Point
         {
             public int x;
             public int y;
             public Point* next;
             public Point* previous;
         }
    unsafe static void CalcPoint(Point* point)
         {
             //
         }

 也可以在导入非托管 DLL 的函数声明中使用unsafe

  [DllImport("msvcrt.dll", CallingConvention = CallingConvention.Cdecl)]
  private static extern unsafe int memcpy(void* dest, void* src, int count);

注意：

指针不能指向引用或包含引用的结构，因为无法对对象引用进行垃圾回收，即使有指针指向它也是如此。 垃圾回收器并不跟踪是否有任何类型的指针指向对象。

下面的示例代码可以说明：

    /// <summary>
    /// 声明一个Point结构体
    /// </summary>
    struct Point
    {
        public int x;
        public int y;      
    }

      static void Main(string[] args)
        {
            unsafe
            {
                //编译正常
                Point p = new Point();
                Point* pp = &p;
            }
        }
  //换成类
  class Point
     {
         public int x;
         public int y;      
     }

在C#中使用指针的示例代码

 4、*和&操作符

在不安全的上下文中，可以使用 * 操作符构建数据类型相对应的指针类型(指针类型、值类型和引用类型，示例代码中的type)，使用 & 操作符获取被指向的内存地址。

 type* identifier;
 void* identifier; //允许但不推荐

 下面是使用*操作符进行指针类型声明

int* pp 是指向整数的指针。
int** pphttp://www.devze.com 是指向整数的指针的指针。
int*[] pp 是指向整数的指针的一维数组。
char* pp 是指向字符的指针。
void* pp 是指向未知类型的指针。

注意：

1、无法对 void* 类型的指针应用间接寻址运算符。 但是，你可以使用强制转换将 void 指针转换为任何其他指针类型，反过来也是可以的。

2、指针类型不从object类继承，并且指针类型与 object 之间不存在转换。 此外，ZdOhiJkRd装箱和取消装箱不支持指针。 

下面的代码演示了如何声明指针类型：

 static void Main(string[] args)
         {
             int []a = { 1, 2, 3, 4, 4 };
 
             unsafe
             {
                 //临时固定一个变量以使它的地址可被找到
                 fixed (int* p = &a[0])
                 {
                     int* p2 = p;
                     Console.WriteLine(*p2);
                     p2++;
                     Console.WriteLine(*p2);
                     p2++;
                     Console.WriteLine(*p2);
                 }
             }
 
         }

 输出结果如下：

1

2

3

下面的代码演示了如何使用指针类型进行数据交换：

 static void Main(string[] args)
         {
             int a = 1;
             int b = 2;
 
             unsafe
             {
                 UnsafeSwap(&a, &b);
             }
 
             Console.WriteLine(a);
             Console.WriteLine(b);
         }
 
         /// <summary>
         /// 使用指针
         /// </summary>
         /// <param name="a"></param>
         /// <param name="b"></param>
         static unsafe void UnsafeSwap(int* a,int *b)
         {
             int temp = *a;
             *a = *b;
             *b = temp;
         }
 
         /// <summary>
         /// 不使用指针的安全版本
         /// </summary>
         /// <param name="a"></param>
         /// <param name="b"></param>
         static void SafeSwap(ref int a,ref int b)
         {
             int temp = a;
             a = b;
             b = temp;
         }

输出结果如下：

2

1

5、通过指针访问字段

定义如下结构体

  struct Point
         {
             public int x;
             public int y;
 
             public override string ToString()
             {
                 return $"x:{x},y:{y}";
             }
         }

如果声明一个Point类型的指针，就需要使用指针字段访问操作符(->)来访问公共成员（和C++一样），也可以使用指针间接寻址操作符(*)来解除指针的引用，使其也可以使用 (.)操作符访问字段（和C++一样）。

 static unsafe void Main(string[] args)
         {
             //通过指针访问成员
             Point point = new Point();
python             Point* p = &point;
             p->x = 10;
             p->y = 5;
             Console.WriteLine(p->ToString());
 
             //通过指针间接寻址访问成员
             Point point2; //不使用 new 运算符的情况下对其进行实例化,需要在首次使用实例之前必须初始化所有实例字段。
             Point* p2 = &point2;
             (*p2).x = 128;
             (*p2).y = 256;
             Console.WriteLine((*p2).ToString());
         }

运行结果如下：

x:10,y:5

x:128,y:256

6、stackalloc关键字

在不安全上下文中，可能需要声明一个直接从调用栈分配内存的本地变量（不受.Net垃圾回收器控制）。C#提供了与CRT函数_alloca等效的stackalloc关键字来满足这个需求。

 static unsafe void Main(string[] args)
         {
             char* p = stackalloc char[3];
 
             for (int i = 0; i < 3; i++)
             {
                 p[i] = (char)(i+65); //A-C
             }
 
             Console.WriteLine(*p);
             Console.WriteLine(p[0]);
 
             Console.WriteLine(*(++p));
             Console.WriteLine(p[0]);
 
             Console.WriteLine(*(++p));
             Console.WriteLine(p[0]);
         }

输出结果如下：

A

A

B

B

C

C

7、fixed关键字

在上面的示例中，我们可以看到，通过stackalloc关键字，在不安全上下文中分配一大块内存非常方便。但这块内存是在栈上的，当分配方法返回的时候，被分配的内存立即被清理。

假设有如下情况：

声明一个引用类型PointRef和一个值类型Point

     class PointRef
         {
             public int x;
             public int y;
 
             public override string ToString()
             {
                 return $"x:{x},y:{y}";
             }
         }
 
         struct Point
         {
     javascript        public int x;
             public int y;
 
             public override string ToString()
             {
                 return $"x:{x},y:{y}";
             }
         }

调用者声明了一个PointRef类型的变量，内存将被分配在垃圾回收器堆上。如果一个不安全的上下文要与这个对象（或这个堆上的任何对象）交互，就可能会出现问题，因为垃圾回收可随时发生。设想一下，恰好在清理堆的时候访问Point成员，这就很

为了将不安全上下文中的引用类型变量固定，C#提供了fixed关键字，fixed语句设置指向托管类型的指针并在代码执行过程中固定该变量。换句说话：fixed关键字可以锁定内存中的引用变量。这样在语句的执行过程中，该变量地址保持不变。

事实上，也只有使用fixed关键字，C#编译器才允许指针指向托管变量。

 static unsafe void Main(string[] args)
         {
             PointRef pointRef = new PointRef();
             Point point = new Point();
 
             int a = &pointRef.x;  //编译不通过
 
             int *b = &point.x;    //编译通过
 
             fixed(int *c = &pointRef.x)
             {
                 //编译通过
             }
         }

说明：

在fixed中初始化多个变量也是可以的

            //同时声明多个指针变量的语法跟C++中的不一样，需要注意
             fixed(int *e = &(pointRef.x) , f = &(pointRef.y) )
             {
 
             }

8、sizeof关键字

在不安全上下文中，sizeof关键字用于获取值类型（不是引用类型）的字节大小。sizeof可计算任何由System.ValueType派生实体的字节数。

    static  void Main(string[] args)
         {
             unsafe
             {
                 //不安全版本
                 Console.WriteLine(sizeof(int));
                 Console.WriteLine(sizeof(float));
                 Console.WriteLine(sizeof(Point));
             }
 
             //安全版本
             Console.WriteLine(Marshal.SizeOf(typeof(int)));
             Console.WriteLine(Marshal.SizeOf(typeof(float)));
             Console.WriteLine(Marshal.SizeOf(typeof(Point)));
 
         }php

9、避免使用指针

事实上在C#中，指针并不是新东西。因为在代码中可以自由使用引用 ，而引用就是一个类型安全的指针。指针只是一个存储地址的变量，这和引用其实是一个原理。引用的主要作用是使C#更易于使用，防止用户无意中执行某些破坏内存中内容的操作。

使用指针后，可以进行低级的内存访问，但这是有代价的，使用指针的语法比引用类型的语法复杂得多，而且指针使用起来也比较困难，需要较高的编程技巧和强力。如果不仔细，就容易在程序中引入细微的，难以查找的错误。另外，如果使用指针，就必须授予代码运行库的代码访问安全机制的高级别信任，否则就不能执行它。

MSDN上有如下关于指针的说明：

在公共语言运行时 (CLR) 中，不安全代码是指无法验证的代码。 C# 中的不安全代码不一定是危险的；只是 CLR 无法验证该代码的安全性。 因此，CLR 将仅执行完全信任的程序集中的不安全代码。 如果你使用不安全代码，你应该负责确保代码不会引发安全风险或指针错误。

大多数情况下，可以使用System.Intptr或ref关键字来替代指针完成我们想要的操作。

下面使用示例代码说明一下：（仅供演示）

这里还是以memcpy函数为例，假设我有一个Point结构的实例，要对这个Point进行拷贝。

声明Point结构

 struct Point
     {
         public int x;
         public int y;
     }

使用System.IntPtr：

         /// <summary>
         /// 使用IntPtr
         /// </summary>
         /// <param name="pDst"></param>
         /// <param name="pSrc"></param>
         /// <param name="count"></param>
         /// <returns></returns>
         [DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl)]
         private static extern unsafe int memcpyi(IntPtr pDst, IntPtr pSrc, int count);
         static void MemCpyIntPtr()
         {
             var p = new Point() { x = 200,y = 10};
             Console.WriteLine(p.x + " " + p.y);
  
             var size = Marshal.SizeOf(p);
             
             IntPtr ptrSrc = Marshal.AllocHGlobal(size);
             IntPtr ptrDest = Marshal.AllocHGlobal(size);
 
             //将结构体Point转换成ptrSrc
             Marshal.StructureToPtr(p, ptrSrc, false);
 
             //memcpy
             memcpyi(ptrDest, ptrSrc, size);
 
             //再转换成结构体
             Point p2 = new Point();
             //先输出一次进行对比
             Console.WriteLine(p2.x + " " + p2.y);
 
             p2 = (Point)Marshal.PtrToStructure(ptrDest, typeof(Point));
             Console.WriteLine(p2.x + " " + p2.y);
 
         }

运行结果如下：

200 10

0 0

200 10

使用指针：

         /// <summary>
         /// 使用指针
         /// </summary>
         /// <param name="pDst"></param>
         /// <param name="pSrc"></param>
         /// <param name="count"></param>
         /// <returns></returns>
         [DllImport("msvcrt.dll", EntryPoint = "memcpy", CallingConvention = CallingConvention.Cdecl)]
         private static extern unsafe int memcpyp(void* pDst, void* pSrc, int count);
         static unsafe void MemCpyPointer()
         {
             Point p = new Point() { x = 200, y = 10 };
             Point p2 = new Point();
 
             Console.WriteLine(p.x + " " + p.y);
             Console.WriteLine(p2.x + " " + p2.y);
 
             Point* pSrc = &p;
             Point* pDest = &p2;
 
             memcpyp((void*)pDest, (void*)pSrc, sizeof(Point));
 
             p2 = *pDest;
             Console.WriteLine(p2.x + " " + p2.y);
         }

运行结果如下：

200 10

0 0

200 10

下面介绍使用指针传递时的另外一种情况，这种情况我们可以使用ref来代替指针完成操作。

先用C++封装一个库，导出如下函数，用来打印一个整形数组

 extern "C" __declspec(dllexport) void PrintArray(int* pa,int size);
 
 
 extern "C" __declspec(dllexport) void PrintArray(int* pa,int size)
 {
     for (size_t i = 0; i < size; i++)
     {
         std::cout << *pa << std::endl;
         pa++;
     }
 }

使用ref：

 [DllImport("demo_lib.dll",EntryPoint = "PrintArray")]
 private static extern void PrintArrayRef(ref int pa,int size);
         static void PrintArrayRef()
         {
             int[] array = new int[] { 1,2,3};
 
             //使用ref关键字传的是引用，ref[0]其实就是传的首地址
            PrintArrayRef(ref array[0], array.Length);
         }

运行结果：

1

2

3

使用指针：

         [DllImport("demo_lib.dll", EntryPoint = "PrintArray")]
         private static extern unsafe void PrintArrayPointer(int* pa, int size);
         static unsafe void PrintArrayPointer()
         {
             int size = 3;
             int* array = stackalloc int[3];
 
             for (int i = 0; i < size; i++)
             {
                 array[i] = i+1;
             }
             PrintArrayPointer(array, size);
         }

运行结果：

1

2

3

以上就是在C#中使用指针的示例代码的详细内容，更多关于C#使用指针的资料请关注编程客栈(www.devze.com)其它相关文章！

0

上一篇:

:下一篇

更多 开发 相关资讯：

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

关注公众号

热门标签

图文推荐

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题

mysql字符集引起的java.sql.SQLException:Incorrect string value:问题
解决Feign异步调用丢失上下文问题

解决Feign异步调用丢失上下文问题
一文教会你使用Python来下一场雪

一文教会你使用Python来下一场雪
利用python调整Excel行高和列宽的操作示例

利用python调整Excel行高和列宽的操作示例
Python字符串检索方式

Python字符串检索方式
Android中常见内存泄漏的场景和解决方案详解

Android中常见内存泄漏的场景和解决方案详解
python解析网页上的json数据并保存到EXCEL

python解析网页上的json数据并保存到EXCEL
使用wxPython创建一个文件夹结构生成器

使用wxPython创建一个文件夹结构生成器

开发者开发者网给大家分享系统运维,大数据运维,云计算,编程开发技巧,路由交换,运维和开发相关的资讯及技术文章，同时StackOverflow中文社区，知识经验交流分享。

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，如存在版权或非法内容，欢迎举报，我们将尽快予以删除。邮箱：devze@qq.com

Copyright © 2018-2020 开发者. All rights reserved. Powered by 开发者ICP备案号: 京ICP备10032868号-9