Stack vs Heap in Solidity

Solidity uses stack and heap memory models similar to traditional programming languages. Understanding how data is handled in stack and heap helps developers write more efficient and optimized smart contracts.

1. Stack

• Definition: A small, fast, temporary storage for value types such as uint, bool, and address.
• Size Limit: Limited to 1024 slots per function call.
• Scope: Local value-type variables inside functions are stored on the stack.
• Gas Cost: Very cheap compared to storage operations.

Stack is ideal for simple calculations and temporary variables because it is extremely fast and automatically managed by the EVM.

2. Heap

• Definition: Heap is used for reference types such as arrays, structs, and mappings.
• Scope: Includes both memory and storage locations.
• Gas Cost: Memory allocation is cheaper than storage, but storage writes are the most expensive.

Heap is necessary for handling dynamic data structures that cannot fit into the stack.

Example:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

contract StackHeapExample {
    uint256 public storedData; // Storage (heap)
    
    function stackExample() public pure returns (uint256) {
        uint256 x = 10; // Stack
        uint256 y = 20; // Stack
        return x + y;
    }
    
    function heapExample(uint256[] memory arr) public pure returns (uint256) {
        uint256[] memory temp = arr; // Memory allocation (heap)
        temp[0] = temp[0] * 2;
        return temp[0];
    }
}

In this example:

• x and y are stored on the stack because they are simple value types.
• storedData resides in storage, which is part of the heap.
• temp is a dynamic array stored in memory, also part of the heap.

Key Takeaway: Use the stack for small, temporary value-type variables and the heap for dynamic or reference-type data structures to balance performance and gas efficiency.