如何在 C# 中创建一个包含数组但不使用堆的结构？

Question

What i need:

• a polygon with arbitrary amount of vertices ( or at least up to max number of vertices )
• it should be a struct, so that it can be fast and can be assigned / passed by value

It seems like i can't use arrays or collections for storing vertices, because then my polygon struct would point to objects on a heap, and when one polygon is assigned to another one by value only shallow copy would be performed, and i would have both polygons pointing to the same vertex array. For example:

Polygon a = new Polygon(); 
Polygon b = a; 
// both polygons would be changed 
b.vertices[0] = 5; 

Then how do i create a struct that can have arbitrary number (or some fixed number) of vertices, but without using heap at all?

I could just use lots of variables like v1, v2, v3 ... v10 etc, but i want to keep my code clean, more or less.

Answer 1

You have the option to define your array with the fixed keyword, which puts it in the stack.

But you cannot directly access the elements of the array, unless you are in an unsafe context and use pointers.

To get the following behavior:

    static void Main(string[] args)
    {
        FixedArray vertices = new FixedArray(10);
        vertices[0] = 4;

        FixedArray copy = vertices;
        copy[0]  = 8;
        Debug.WriteLine(vertices[0]);
        // 4
        Debug.WriteLine(copy[0]);
        // 8
    }

Then use the following class definition:

public unsafe struct FixedArray 
{
    public const int MaxSize = 100;

    readonly int size;
    fixed double data[MaxSize];

    public FixedArray(int size) : this(new double[size])
    { }

    public FixedArray(double[] values)
    {
        this.size = Math.Min(values.Length, MaxSize);
        for (int i = 0; i < size; i++)
        {
            data[i] = values[i];
        }
    }

    public double this[int index]
    {
        get
        {
            if (index>=0 && index<size)
            {
                return data[index];
            }
            return 0;
        }
        set
        {
            if (index>=0 && index<size)
            {
                data[index] = value;
            }
        }
    }

    public double[] ToArray()
    {
        var array = new double[size];
        for (int i = 0; i < size; i++)
        {
            array[i] = data[i];
        }
        return array;
    }        
}

A couple of things to consider. The above needs to be compiled with the unsafe option. Also the MaxSize but be a constant, and the storage required cannot exceed this value. I am using an indexer this[int] to access the elements (instead of a field) and also have a method to convert to a native array with ToArray() . The constructor can also take a native array, or it will use an empty array to initialize the values. This is to ensure that new FixedArray(10) for example will have initialized at least 10 values in the fixed array (instead of being undefined as it is the default).

Read more about this usage of fixed from Microsoft or search for C# Fixed Size Buffers .

• Heap array field

   struct StdArray { int[] vertices; Foo(int size) { vertices = new int[size]; } }

• Stack array field

   unsafe struct FixedArray { fixed int vertices[100]; int size; Foo(int size) { this.size = size; // no initialization needed for `vertices` } }

Answer 2

If it suits your logic, you could use a Span<T> , which is allocated on the stack. Read more here

Answer 3

One other way to just copy the array with a copy constructor

public Polygon(Polygon other)
{
    this.vertices = other.vertices.Clone() as int[];
}

then

var a = new Polygon();
a.vertices[0] = 5;

var b = new Polygon(a):
Debug.WriteLine(a.vertices[0]);
// 5
Debug.WriteLine(b.vertices[0]);
// 5

b.vertices[0] = 10;
Debug.WriteLine(a.vertices[0]);
// 5
Debug.WriteLine(b.vertices[0]);
// 10