How to deal with arrays inside a struct?

Question

I'm looking for a way to replace some of my List objects with arrays in my project to boost performance. The reasoning is that the List I would replace do not change size often (sometimes only once), so it would make sense to swap them out with arrays. Also, I would like to prevent allocations on the heap as much as possible.

So my idea is to create a struct (ArrayStruct) with two members "Count" and "Array". The struct would have some functions to add/remove/get/set/ect... elements in the array. The count would keep count of the elements that are usable in the array, and the array would only increase in size, never decrease. Note that this is for a very particular case because I know the array size won't be very big.

The main problem I have is when I pass the reference to an already existing ArrayStruct object (named a in the example) to another (named b in the example) - I can edit the array in it, but once I resize it in a, I get an out of range exception in b. Is this because of the way I'm updating the reference via System.Array.Resize, so that the object b somehow does not attribute this change?

The only thing I could come up with as an idea was trying to override the assignment operator so that it would create a new array on assignment... but obviously that does not work.

My ArrayStruct

    public struct ArrayStruct<T>
    {
        [SerializeField] private int m_Count;
        [SerializeField] private T[] m_Array;

        public int Count => m_Count;

        public void Initialize(int startSize)
        {
            m_Count = 0;
            m_Array = new T[startSize];
        }

        public T GetAt(int index)
        {
            return m_Array[index];
        }

        public void SetAt(int index, T newValue)
        {
            m_Array[index] = newValue;
        }

        public void Add(T newElement)
        {
            if (m_Array == null) {
                m_Array = new T[1];
            } else if (m_Array.Length == m_Count) {
                System.Array.Resize(ref m_Array, m_Count + 1);
            }

            m_Array[m_Count] = newElement;
            m_Count++;
        }

        public void Remove(T element)
        {
            for (int i = 0; i < m_Count; ++i) {
                if (!element.Equals(m_Array[i])) {
                    continue;
                }

                for (int j = index; j < m_Count - 1; ++j) {
                    m_Array[j] = m_Array[j + 1];
                }
                m_Count--;
                m_Array[m_Count] = default(T);
                break;
            }
        }

        //Trying to overload the = operating by creating a auto cast, this gives a compile error
        /*public static implicit operator ArrayStruct<T>(ArrayStruct<T> otherArray)
        {
            var newArray = new ArrayStruct<T>();
            newArray.m_Count = otherArray.Count;
            newArray.m_Array = new T[otherArray.Length];
            otherArray.m_Array.CopyTo(newArray.m_Array);
            return newArray;
        }*/

An example showcasing the problem

var a = new ArrayStruct<string>()
a.Add("hello");
var b = a;
print (b.GetAt(0)); //"hello"

a.SetAt(0, "new value for a");

print(b.GetAt(0));//"new value for a"  , changing a changed b because the array is the same in both, this is bad

a.Add("resizing array");
print (b.GetAt(1)); //"Out of range exception" ,  because the array was resized for a but not for b therefore the connection broke

So do any of you have an idea of how I could make a new copy the array when I assign the struct to another variable? Of course, I know I could use a function to do something like so b = new ArrayStruct(a); But I want it to be implicit. Or if there was a way to prevent assignments that would also work for me. var a = new ArrayStruct();//let this work var b = a; //Prevent this from happening

If you have any other solutions for replacing Lists with arrays conveniently please let me know

Answer 1

So do any of you have an idea of how I could make a new copy the array when I assign the struct to another variable? Of course, I know I could use a function to do something like so b = new ArrayStruct(a); But I want it to be implicit.

You can't do that. If a is a struct and you execute var b = a, then it will always just set b to a shallow copy of a; there's no way to change that behavior.

Doing something like b = new ArrayStruct(a) is the best you can do.

Answer 2

You're not understanding what the "=" operator is doing there. Objects are defined by reference, meaning when you write var b = a; you are actually asking for what you wish to avoid to happen, that is - object "b", pointing to the same object, which is "a". You're passing the object "b" to point to the reference of object "a", which object holds the address to the object in question you defined, using the new keyword var a = new ArrayStruct<string>()

Your operator overloading does not work because you can't use it for conversions of the same type as the class you're writing the operator in. You'd either have to make a separate object (class), which would defeat the point you're trying to fix, or pass the m_array instead: public static implicit operator ArrayStruct<T>(T[] array)

You can also do something like this:

        public static ArrayStruct<T> CopyFrom (ArrayStruct<T> array)
    {
        var newArray = new ArrayStruct<T>();
        newArray.m_Array = new T[array.Count + 1];
        newArray.Count = array.Count;
        Array.Copy(array.m_Array, 0, newArray.m_Array, 0, array.m_Array.Length);
        return newArray;
    }

Now it should work exactly as you wanted.

    var a = new ArrayStruct<string>();
    a.Add("hello");
    var b = ArrayStruct<string>.CopyFrom(a);

    a.SetAt(0, "new value for a");


    a.Add("resizing array");

    Console.WriteLine(b.Count); // b returns 1
    Console.WriteLine(a.Count); // a returns 2

As to why your index was going out of bounds, i.e it did not preserve the reference found in "a", this is all in correlation with references, yet again.

In the following code System.Array.Resize(ref m_Array, Count + 1); you're changing the reference found for object m_array in "a", when you're adding the new element with the line a.Add("resizing array");. That essentially means that your "a" object's m_array (which is another object of type array[]) is now pointing to a new object (of type array[]), which is of a new size. Okay, but object "a" is now using the new reference, whilst object "b" is still using the old one. m_array in object "b" only has a single element, while the new m_array object in "a" has the newly added element "resizing array", along with any previously added ones.

I believe that's how System.Array.Resize works? Edit me if I'm wrong.

Below is a resource explaining how to do a deep cloning of an object, if that's what you truly wish to do (i.e create a completely new copy of an object, as well as any other objects inside)

---

Deep cloning of objects