In Solidity, variables can be stored in different places based on their scope and the duration of storage. The main storage locations in Solidity are:

1. Memory:

   • Scope: Temporary data storage during the execution of a function.
   • Duration: Limited to the duration of the function call.
   • Example:

    function add(uint256 a, uint256 b) external pure returns (uint256) {
        // Using memory for temporary variables
        uint256 result = a + b;
        return result;
    }
   

2. Storage:

   • Scope: Persistent data storage on the Ethereum blockchain.
   • Duration: Persists across function calls and transactions.
   • Example:

    contract StorageExample {
        uint256 public storedData;  // Stored in storage
   
        function set(uint256 newValue) external {
            // Setting value in storage
            storedData = newValue;
        }
   
        function get() external view returns (uint256) {
            // Reading value from storage
            return storedData;
        }
    }
   

3. Stack:

   • Scope: Temporary storage for small, local variables within a function.
   • Duration: Limited to the function's execution.
   • Example:

    function calculateSum(uint256 a, uint256 b) external pure returns (uint256) {
        // Using stack for temporary variables
        uint256 sum = a + b;
        return sum;
    }
   

Understanding the distinction between these storage locations is crucial for writing efficient and gas-optimized Solidity code. Memory is typically used for temporary variables within functions, storage is used for persistent data on the blockchain, and the stack is reserved for small, short-lived variables within a function's execution.