Is this a copy or a pointer?

My question is, is "spriteArray" in class ChunkScript an complete copy of the array in class TileMapScript or only an "fast and no memory usage" pointer to the original sprite array?

The object with this script attached has the tag: "obj_TileMap"

Code (CSharp):

1. public class TileMapScript : MonoBehaviour {
2.     public List<GameObject> chunks = new List<GameObject>();
3.     public Sprite[] Sprites;
4.  
5.     //Generate
6.    GameObject chunk = new GameObject();
7.    chunk.AddComponent<ChunkScript>();
8.    chunk.GetComponent<ChunkScript>().Build();
9.    chunks.Add(chunk);
10. }

Code (CSharp):

1. public class ChunkScript : MonoBehaviour
2. {
3. void Build()
4.     {
5.         GameObject reference = GameObject.Find("obj_TileMap");
6.         Sprite[] spriteArray = reference.GetComponent<TileMapScript>().blockSprites;
7.     }
8. }

 

Arrays are always pointers unless you explicitly tell them to be otherwise.

 

!!!

 

Technically C# does not support pointers unless you place it in 'unsafe' mode.
https://msdn.microsoft.com/en-us/library/y31yhkeb.aspx

These are 'reference types'. Which means that when you pass the object from variable to variable, the reference is moved. This is more like a half-pointer. The variable takes a copy of the handle to the object in managed memory... thing is a reference might move around in managed memory, so it's not exactly a pointer. A pointer is a copy of a byte address in memory, a pointer can point at any point in memory.


In your case, an array is a referenced object, not a value.

You can know if you have a reference if it is a 'class'. A really quick way to decipher this is if you can set the variable to 'null'.

You can tell it's a value type if it's a struct, enum, or other primitive type. A really quick way to decipher this is if you can NOT set the variable to null.

 

Code (csharp):

1. Nullable<int> example = null;

 

Yes, there are exceptions.

Although this is technically a hack on the part of the language. The underlying fields of 'Nullable<T>' are the value you want to store, and a bool. 'null' is converted to the bool as false, denoting the value should be ignored.

 

@kietus & @StarManta
Have one or both of you an better solution to get this spriteArray?
I hate GameObject.Find too!

And thank you all for your explanation.

 

I would probably use a singleton in this case:

Code (csharp):

1. public class TileMapSprite : MonoBehaviour {
2. public static TileMapSprite instance;
3. void Awake() {
4. instance = this;
5. }
6. // rest of the script
7. ...
8.  
9. //in your other script
10.         Sprite[] spriteArray = TileMapScript.instance.blockSprites;
11.  

 

Static variables which only get initialised once can also be useful for your use case.

 

I don't get it up to work, it is driving me insane
I got an NullReferenceException

I debug with VS and everything works fine, I can follow the code with the singlestep until the "debug-line" finish my script (TileMapChunk.cs:128!).

If I press again F11 (singlestep) the known yellow line is gone, 22 more singlesteps (I do not know where the dubugger is), it throws an NullReferenceException:

But the info "TileMapChunk.cs:128" can't be corrrect, beause the error happens exact 22 singlesteps later.

Can someone tell me how to find the real NullReference?

 

Please start a new thread about it

 

This actually makes me wonder that what's the point of pointers. I mean references in C# are much safer and like pointers. You can make it reference it to something else make it null and GC is already deleting them. I wonder why would someone use them in C#? Is there something performance related?

 

They're used in rare situations, dealing with performance-critical code, and a couple other things. They give some advantages, but most situations don't need them.

https://msdn.microsoft.com/en-us/library/aa288474(VS.71).aspx

 

@Yash987654321 I found the problem while testing/fooling around

I will open a new topic, in hope someone can explain (or link) this "debug"-problem.
---------------------------------------------------------------------------------
I create an empty game obj at runtime:

Code (CSharp):

1. GameObject xyz = new GameObject()
2. xyz.Init(); <== (Code below)

Fill it with componets to draw something into the scene:

Code (CSharp):

1.         this.gameObject.AddComponent<MeshFilter>();
2.         this.gameObject.AddComponent<MeshCollider>();
3.         this.gameObject.AddComponent<MeshRenderer>();
4.         ...
5.         MeshRenderer mesh_renderer = this.GetComponent<MeshRenderer>();
6.         ...
7.         mesh_renderer.sharedMaterial.mainTexture = texture; // <== KILL'S IT!
8.         mesh_renderer.material.mainTexture = texture; // FIX IT!

But my "Fix" is the next problem, it seems that I need an external Material or something like that, because the Unity (compiler?) grouses with me, that the material will be copied into the scene.

 

Pointers are faster. Pointing directly to physical memory allows you to do some insane things too.

We used pointers a lot in older scanning PLCs. The only data structures that exist are bits and ints. Ints are just 16 bits in sequence. You can do some surprising things with just this level of data. Most of it revolves around pointers.