Visibility modifiers (public, private, internal, external) in Blockchain / Solidity - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Solidity contract call?

Consider the following Solidity contract snippet. What will be the output when callPublic() is called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract VisibilityTest {
    string private secret = "hidden";
    string public info = "visible";

    function getSecret() private view returns (string memory) {
        return secret;
    }

    function callPublic() public view returns (string memory) {
        return info;
    }
}

A "" (empty string)

B "visible"

C "hidden"

D Compilation error due to private function call

💡 Hint

Remember that public variables create getter functions accessible externally.

The info variable is declared public, so calling callPublic() returns its value "visible". The private function getSecret() is not called here.

❓ Predict Output

intermediate

What error occurs when calling a private function externally?

What happens if an external caller tries to call the private function getSecret() from the contract below?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract VisibilityTest {
    string private secret = "hidden";

    function getSecret() private view returns (string memory) {
        return secret;
    }
}

A Returns "hidden" successfully

B Runtime error: function call fails

C Returns empty string

D Compilation error: function is private and cannot be called externally

💡 Hint

Private functions are only callable inside the contract.

Private functions cannot be called from outside the contract, so trying to call getSecret() externally causes a compilation error.

❓ Predict Output

advanced

What is the output of calling an internal function from a derived contract?

Given the following contracts, what will Derived.getInternal() return?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract Base {
    string internal data = "base data";

    function getData() internal view returns (string memory) {
        return data;
    }
}

contract Derived is Base {
    function getInternal() public view returns (string memory) {
        return getData();
    }
}

A "base data"

B Compilation error: internal function cannot be called

C Runtime error: function call fails

D "" (empty string)

💡 Hint

Internal functions are accessible in derived contracts.

The internal function getData() is accessible inside the derived contract Derived, so calling getInternal() returns "base data".

❓ Predict Output

advanced

What happens when an external function is called internally?

Consider this contract. What will happen if callExternal() is called?

Blockchain / Solidity

pragma solidity ^0.8.0;

contract VisibilityTest {
    function externalFunc() external pure returns (string memory) {
        return "external called";
    }

    function callExternal() public view returns (string memory) {
        return externalFunc();
    }
}

A Runtime error: external function call fails

B "external called"

C Compilation error: external function cannot be called internally without this.

D "" (empty string)

💡 Hint

External functions require a special call syntax when called internally.

External functions cannot be called internally by simple function call syntax. They must be called using this.externalFunc(). Otherwise, it causes a compilation error.

🧠 Conceptual

expert

Which visibility modifier allows function calls only from within the contract and derived contracts, but not externally?

Choose the visibility modifier that restricts function access to the contract itself and any contracts that inherit from it, but disallows external calls.

A internal

B private

C public

D external

💡 Hint

Think about which modifier allows inheritance access but blocks external calls.

internal functions and variables are accessible inside the contract and in derived contracts, but not from outside. private restricts access only to the contract itself.