Solidity

Scope of Variables

• Scope means the part of the program where a variable can be used.
• The scope of a local variable is limited to the block { ... } in which it is declared – from its declaration to the closing brace (the same rule as C99). It cannot be used outside that block.
• State variables are available to all functions of the contract. Their visibility to other contracts is controlled by three visibility specifiers.

Visibility of State Variables

• public − can be accessed internally and also from outside the contract. For every public state variable the compiler automatically generates a getter function with the same name.
• internal − can be accessed only from inside the current contract and from contracts that inherit from it (without using this). This is the default when no visibility is written.
• private − can be accessed only inside the contract in which it is defined, not in derived (child) contracts.

external is a visibility for functions only (Chapter 15); it cannot be applied to state variables.

Example : Visibility and Block Scope

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

contract Parent {
    uint public   publicData   = 10;   // getter publicData() is generated
    uint internal internalData = 20;   // visible here and in children
    uint private  privateData  = 30;   // visible only in Parent

    function readPrivate() public view returns (uint) {
        return privateData;            // allowed: same contract
    }
}

contract Child is Parent {
    function readInherited() public view returns (uint) {
        // return privateData;         // compile error: private is not inherited
        return publicData + internalData;   // 10 + 20 = 30
    }

    function blockScope() public pure returns (uint) {
        uint total = 0;
        for (uint i = 1; i <= 3; i++) {    // i exists only inside the loop
            uint square = i * i;           // square exists only inside this block
            total += square;
        }
        // return square;               // compile error: out of scope
        return total;                  // 1 + 4 + 9 = 14
    }
}

contract Outsider {
    function readFromParent(Parent p) public view returns (uint) {
        return p.publicData();         // only public data is reachable via its getter
    }
}

Key Takeaways

The PDF E-Notes are the earlier printable version of this chapter. The notes on this page are the latest, revised version.

Video : Scope and Visibility of Variables

Resource File

• Chapter 5 : Solidity File

Question / Answer (15 questions)

MCQ Test : Check Your Understanding (5 questions)

Select an option and press Check Answer, or answer all questions and press Submit Test to see your score. Each answer comes with an explanation.

Bibliography/References

The notes, questions and MCQs on this page are original explanations written for this course. The works listed below were consulted and are cited for attribution and further reading. Product names, logos and trademarks belong to their respective owners. Short quotations, where used, are marked and attributed.

1. Solidity Team. (n.d.). Contracts (creating contracts, visibility and getters, function modifiers, constant and immutable, functions, events, custom errors, inheritance, abstract contracts, interfaces, libraries). Solidity Documentation. https://docs.soliditylang.org/en/latest/contracts.html
2. Solidity Team. (n.d.). Expressions and Control Structures (if/else, loops, checked arithmetic, error handling, try/catch). Solidity Documentation. https://docs.soliditylang.org/en/latest/control-structures.html
3. Solidity Team. (n.d.). Security Considerations. Solidity Documentation. https://docs.soliditylang.org/en/latest/security-considerations.html
4. Modi, R. (2018). Solidity Programming Essentials: A beginner’s guide to build smart contracts for Ethereum and blockchain. Packt Publishing. ISBN 978-1-78883-138-3.