c# - 在 C# 中数据类型* 表示

Question

这究竟意味着什么

数据类型*

示例：int*、double*、char*、...

任何人都可以给它一些解释。

提前致谢。

Answer 1

这是一个不安全的指针。不安全代码教程

这是一个使用它的示例：如何使用正则表达式提取 alpha 和 count 数字？

private static unsafe List<long> ParseNumbers(char[] input)
{
    var r = new List<long>();

    fixed (char* begin = input)
    {
        char* it = begin, end = begin + input.Length;

        while (true)
        {
            while (it != end && (*it < '0' || *it > '9')) 
                ++it;

            if (it == end) break;

            long accum = 0;
            while (it != end && *it >= '0' && *it <= '9') 
                accum = accum * 10 + (*(it++) - '0');

            r.Add(accum);
        }
    }

    return r;
}

Answer 2

查看指针类型（C# 编程指南）

在不安全的上下文中，类型可能是指针类型、值类型或引用类型。指针类型声明采用以下形式之一：

类型*标识符；

无效*标识符；//允许但不推荐

Answer 3

这些是指针类型。

在不安全的上下文中，类型可能是指针类型以及值类型或引用类型。指针类型声明采用以下形式之一：

 type* identifier;
 void* identifier; //allowed but not recommended

Answer 4

他们叫Pointer types

在不安全的上下文中，类型可能是指针类型以及值类型或引用类型。但是，指针类型也可以在不安全上下文之外的 typeof 表达式中使用，因为这种用法不是不安全的。

指针类型写为非托管类型或关键字 void，后跟 * 标记：

指针类型中 * 之前指定的类型称为指针类型的引用类型。它表示指针类型的值所指向的变量的类型。

与引用（引用类型的值）不同，垃圾收集器不跟踪指针——垃圾收集器不知道指针及其指向的数据。由于这个原因，不允许指针指向引用或包含引用的结构，并且指针的引用类型必须是非托管类型。

Answer 5

这是c#中的指针

请花点时间阅读这个不安全的代码教程

using System;

class Test
{
    // The unsafe keyword allows pointers to be used within
    // the following method:
    static unsafe void Copy(byte[] src, int srcIndex,
        byte[] dst, int dstIndex, int count)
    {
        if (src == null || srcIndex < 0 ||
            dst == null || dstIndex < 0 || count < 0)
        {
            throw new ArgumentException();
        }
        int srcLen = src.Length;
        int dstLen = dst.Length;
        if (srcLen - srcIndex < count ||
            dstLen - dstIndex < count)
        {
            throw new ArgumentException();
        }


            // The following fixed statement pins the location of
            // the src and dst objects in memory so that they will
            // not be moved by garbage collection.          
            fixed (byte* pSrc = src, pDst = dst)
            {
                  byte* ps = pSrc;
                  byte* pd = pDst;

            // Loop over the count in blocks of 4 bytes, copying an
            // integer (4 bytes) at a time:
            for (int n =0 ; n < count/4 ; n++)
            {
                *((int*)pd) = *((int*)ps);
                pd += 4;
                ps += 4;
            }

            // Complete the copy by moving any bytes that weren't
            // moved in blocks of 4:
            for (int n =0; n < count%4; n++)
            {
                *pd = *ps;
                pd++;
                ps++;
            }
            }
    }


    static void Main(string[] args) 
    {
        byte[] a = new byte[100];
        byte[] b = new byte[100];
        for(int i=0; i<100; ++i) 
           a[i] = (byte)i;
        Copy(a, 0, b, 0, 100);
        Console.WriteLine("The first 10 elements are:");
        for(int i=0; i<10; ++i) 
           Console.Write(b[i] + " ");
        Console.WriteLine("\n");
    }
}

和输出

The first 10 elements are:
0 1 2 3 4 5 6 7 8 9

我牙齿这会给你一个想法，在 c# 中低调的指针以及如何使用它

祝你好运