C#基础之不安全代码讲解

2024-11-30  本文已影响0人  上善若泪

1 不安全代码

1.1 简介

当一个代码块使用 unsafe 修饰符标记时，C# 允许在函数中使用指针变量。不安全代码或非托管代码是指使用了指针变量的代码块。

1.2 指针变量

指针 是值为另一个变量的地址的变量，即，内存位置的直接地址。就像其他变量或常量，必须在使用指针存储其他变量地址之前声明指针。
点击此处了解 C语言之指针详解
指针变量声明的一般形式为：

type* var-name;

下面是指针类型声明的实例：

实例 描述
int* p p 是指向整数的指针
double* p p 是指向双精度数的指针
float* p p 是指向浮点数的指针
int** p p 是指向整数的指针的指针
int*[] p p 是指向整数的指针的一维数组
char* p p 是指向字符的指针
void* p p 是指向未知类型的指针

在同一个声明中声明多个指针时，星号 * 仅与基础类型一起写入；而不是用作每个指针名称的前缀。 例如:

int* p1, p2, p3;     // 正确  
int *p1, *p2, *p3;   // 错误

1.3 编译不安全代码

为了编译不安全代码，必须切换到命令行编译器指定 /unsafe 命令行。
例如，为了编译包含不安全代码的名为 prog1.cs 的程序，需在命令行中输入命令：csc /unsafe prog1.cs
如果使用的是 Visual Studio，那么您需要在项目属性中启用不安全代码。

步骤如下：

1.4 使用示例

1.4.1 简单使用

using System;
namespace UnsafeCodeApplication
{
    class Program
    {
        static unsafe void Main(string[] args)
        {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} ",  var);
            Console.WriteLine("Address is: {0}",  (int)p);
            Console.ReadKey();
        }
    }
}

结果：
Data is: 20
Address is: 99215364

也可以不用声明整个方法作为不安全代码，只需要声明方法的一部分作为不安全代码

1.4.2 使用指针检索数据值

使用 ToString() 方法检索存储在指针变量所引用位置的数据

using System;
namespace UnsafeCodeApplication
{
   class Program
   {
      public static void Main()
      {
         unsafe
         {
            int var = 20;
            int* p = &var;
            Console.WriteLine("Data is: {0} " , var);
            Console.WriteLine("Data is: {0} " , p->ToString());
            Console.WriteLine("Address is: {0} " , (int)p);
         }
         Console.ReadKey();
      }
   }
}

结果：
Data is: 20
Data is: 20
Address is: 77128984

1.4.3 传递指针作为方法的参数

向方法传递指针变量作为方法的参数

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe void swap(int* p, int *q)
      {
         int temp = *p;
         *p = *q;
         *q = temp;
      }

      public unsafe static void Main()
      {
         TestPointer p = new TestPointer();
         int var1 = 10;
         int var2 = 20;
         int* x = &var1;
         int* y = &var2;
         
         Console.WriteLine("Before Swap: var1:{0}, var2: {1}", var1, var2);
         p.swap(x, y);

         Console.WriteLine("After Swap: var1:{0}, var2: {1}", var1, var2);
         Console.ReadKey();
      }
   }
}

结果：
Before Swap: var1: 10, var2: 20
After Swap: var1: 20, var2: 10

1.4.4 使用指针访问数组元素

在 C# 中，数组名称和一个指向与数组数据具有相同数据类型的指针是不同的变量类型。例如，int *p 和 int[] p 是不同的类型。可以增加指针变量 p，因为它在内存中不是固定的，但是数组地址在内存中是固定的，所以不能增加数组 p。
因此，如果您需要使用指针变量访问数组数据，可以像我们通常在 C 或 C++ 中所做的那样，使用 fixed 关键字来固定指针。

using System;
namespace UnsafeCodeApplication
{
   class TestPointer
   {
      public unsafe static void Main()
      {
         int[]  list = {10, 100, 200};
         fixed(int *ptr = list)

         /* 显示指针中数组地址 */
         for ( int i = 0; i < 3; i++)
         {
            Console.WriteLine("Address of list[{0}]={1}",i,(int)(ptr + i));
            Console.WriteLine("Value of list[{0}]={1}", i, *(ptr + i));
         }
         Console.ReadKey();
      }
   }
}

结果：
Address of list[0] = 31627168
Value of list[0] = 10
Address of list[1] = 31627172
Value of list[1] = 100
Address of list[2] = 31627176
Value of list[2] = 200

1.5 fixed

C#中的指针 为什么 还得用 fixed 关键字来固定指针
在 C# 中，使用 fixed 关键字来固定指针的目的是为了保证内存的稳定性，这是因为 C# 在托管环境中使用垃圾回收机制（Garbage Collection, GC）。与 C 语言不同，C# 的对象通常在 托管堆（Managed Heap） 上分配，垃圾回收器会在运行时根据需要移动对象来优化内存，这可能导致指针指向的内存地址发生变化。

1.5.1 为什么需要 fixed

托管对象的移动：垃圾回收器为了整理内存，可能会移动托管堆中的对象，造成指针指向的地址失效或不正确。这是 C# 中的指针需要 fixed 的根本原因。

1.5.2 为什么 int *p 和 int[] p 是不同的类型

在 C# 中，int* p 和 int[] p 其实并不是同一类型，它们虽然都可以指向数组的起始位置，但它们在底层实现和使用方式上存在显著差异。

以下是它们的具体区别：

为什么 int* 和 int[] 是不同类型

指针示例
unsafe
{
    int value = 10;
    int* p = &value;
    Console.WriteLine(*p); // 输出值
    p++; // 增加指针地址
}
数组示例
int[] array = { 1, 2, 3 };
Console.WriteLine(array[0]); // 使用索引访问

1.5.3 示例

使用 fixed 关键字的示例：

unsafe
{
    int[] numbers = { 1, 2, 3, 4, 5 };

    fixed (int* p = numbers) // 固定数组的内存位置
    {
        for (int i = 0; i < 5; i++)
        {
            Console.WriteLine(*(p + i)); // 使用指针访问数组
        }
    } // 离开 fixed 代码块后，指针失效
}

1.6 stackalloc

在 unsafe不安全环境中，我们还可以通过stackalloc在堆栈上分配内存，因为在堆栈上分配的内存不受内存管理器管理，因此其相应的指针不需要固定。

static unsafe void Main(string[] args)
{
  int *ptr = stackalloc int[1] ;
}
上一篇 下一篇

猜你喜欢

热点阅读