Reference types behavior in Blockchain / Solidity

Introduction

Reference types let you work with data by pointing to where it is stored, not copying it. This helps save space and keep data consistent.

When you want multiple parts of your program to share and update the same data.

When working with large data structures to avoid copying them again and again.

When you want changes in one place to automatically show up everywhere else that uses the data.

When managing complex objects like accounts or contracts that need to stay linked.

When you want to pass data efficiently between functions without making copies.

Syntax

Blockchain / Solidity

type MyStruct = struct {
    value: int
}

let a = MyStruct(10)
let b = &a  // b is a reference to a
b.value = 20  // changes a.value too

Reference types store the address of the data, not the data itself.

Changing data through a reference changes the original data.

Examples

Here, y is a reference to the array x. Both share the same data.

Blockchain / Solidity

let x = [1, 2, 3]
let y = &x
// y points to the same array as x
// changing y changes x

acc2 is a reference to acc1. Changing acc2 changes acc1.

Blockchain / Solidity

struct Account {
    balance: int
}

let acc1 = Account(100)
let acc2 = &acc1
acc2.balance = 200
// acc1.balance is now 200

Sample Program

This program shows how changing the amount through wallet2 changes wallet1 because wallet2 is a reference.

Blockchain / Solidity

struct Wallet {
    amount: int
}

let wallet1 = Wallet(50)
let wallet2 = &wallet1

print("Before:", wallet1.amount)
wallet2.amount = 100
print("After:", wallet1.amount)

Important Notes

Be careful: changing data through one reference affects all references to it.

Reference types help save memory but require careful management to avoid bugs.

Summary

Reference types point to data location instead of copying data.

Changes through references affect the original data.

Useful for sharing and updating data efficiently.

Practice

1. In blockchain programming, what happens when you assign one reference type variable to another?

easy

A. The variables become independent and unrelated.

B. A new copy of the data is created.

C. The original data is deleted.

D. Both variables point to the same data location.

Solution

1. Step 1: Understand reference assignment

   Assigning one reference type variable to another makes both point to the same data location in memory.

2. Step 2: Effect of changes through references

   Changes made through either variable affect the same original data because they share the reference.

3. Final Answer:

   Both variables point to the same data location. -> Option D

4. Quick Check:

   Reference assignment shares data location = A [OK]

Hint: Reference types share data location, not copy data [OK]

Common Mistakes:

• Thinking assignment copies data
• Assuming variables become independent
• Believing original data is deleted

2. Which of the following is the correct syntax to copy a reference type variable in Solidity (blockchain language)?

easy

A. uint[] memory newArray = oldArray;

B. uint[] newArray = oldArray.copy();

C. uint[] storage newArray = oldArray;

D. uint[] newArray = copy(oldArray);

Solution

1. Step 1: Understand storage vs memory in Solidity

   Storage variables hold data permanently on blockchain, memory variables are temporary copies.

2. Step 2: Correct way to copy reference

   Assigning a storage reference variable to another storage variable copies the reference, not the data.

3. Final Answer:

   uint[] storage newArray = oldArray; -> Option C

4. Quick Check:

   Storage assignment copies reference = B [OK]

Hint: Use 'storage' keyword to copy reference, not 'memory' [OK]

Common Mistakes:

• Using 'memory' copies data, not reference
• Assuming .copy() method exists
• Trying to use undefined copy functions

3. Consider this Solidity code snippet:

uint[] storage arr1 = someArray;
uint[] storage arr2 = arr1;
arr2.push(10);
uint length = arr1.length;

What is the value of length after execution?

medium

A. Length is unchanged from original someArray length.

B. Length increases by 1 due to push on arr2.

C. Length decreases by 1 due to push on arr2.

D. Code causes a compilation error.

Solution

1. Step 1: Understand reference assignment

   arr2 is assigned as a storage reference to arr1, so both point to the same array.

2. Step 2: Effect of push on arr2

   Pushing 10 to arr2 modifies the shared array, increasing its length by 1.

3. Final Answer:

   Length increases by 1 due to push on arr2. -> Option B

4. Quick Check:

   Shared reference means push affects both = C [OK]

Hint: Changes via one reference affect all references [OK]

Common Mistakes:

• Thinking arr1 length stays same
• Assuming arr2 is a copy
• Ignoring reference sharing behavior

4. Identify the error in this Solidity code snippet:

function updateArray(uint[] memory arr) public {
  uint[] storage ref = arr;
  ref.push(5);
}

medium

A. Cannot assign memory array to storage reference directly.

B. Cannot push to a storage array.

C. Function must be declared view.

D. No error; code runs fine.

Solution

1. Step 1: Check assignment between memory and storage

   In Solidity, you cannot assign a memory array directly to a storage reference variable.

2. Step 2: Understand push operation

   Push is allowed on storage arrays, but assignment error occurs before push.

3. Final Answer:

   Cannot assign memory array to storage reference directly. -> Option A

4. Quick Check:

   Memory to storage assignment invalid = A [OK]

Hint: Memory and storage types cannot be assigned directly [OK]

Common Mistakes:

• Assuming memory can be assigned to storage
• Thinking push is disallowed on storage
• Ignoring data location mismatch

5. You want to create a function in Solidity that returns a modified copy of a storage array without changing the original. Which approach correctly uses reference types to achieve this?

hard

A. Create a new memory array, copy elements from storage, modify it, then return.

B. Assign storage array to a storage reference, modify it, then return.

C. Return the storage array directly after modifying it.

D. Use a global variable to store the modified array.

Solution

1. Step 1: Understand data locations for copying

   To avoid changing original storage array, create a new memory array and copy elements.

2. Step 2: Modify and return the memory array

   Modify the memory array safely and return it without affecting storage data.

3. Final Answer:

   Create a new memory array, copy elements from storage, modify it, then return. -> Option A

4. Quick Check:

   Use memory copy to avoid changing storage = D [OK]

Hint: Copy to memory, modify, then return to keep original safe [OK]

Common Mistakes:

• Modifying storage reference directly
• Returning storage array after modification
• Using global variables unnecessarily