What is the difference between public and private visibility in Solidity?

In the Solidity programming language, controlling the visibility of functions and variables is a crucial aspect, primarily used to determine which other contracts and accounts can access these functions and variables. Solidity offers various visibility options, with public (public) and private (private) being the most frequently utilized.

Public Visibility (public)

Functions and variables declared with the public keyword are accessible from anywhere, both within the contract and externally. This means that other contracts can freely call these public functions or access these variables. For variables, Solidity automatically generates a getter function for public state variables, enabling external access.

Example:

solidity
pragma solidity ^0.8.0;

contract PublicExample {
    uint public publicNumber = 42; // Public state variable

    function publiclyAccessibleFunction() public view returns(uint) {
        return publicNumber; // External contracts can also call this function
    }
}

Private Visibility (private)

In contrast, functions and variables marked with the private keyword can only be accessed within the contract where they are defined. This means that even derived contracts cannot access members marked as private.

Example:

solidity
pragma solidity ^0.8.0;

contract PrivateExample {
    uint private privateNumber = 42; // Private state variable

    function getPrivateNumber() public view returns(uint) {
        return privateNumber; // Only accessible within the contract
    }
}

Summary

Overall, public and private visibility are crucial for controlling access levels to data and functions. Choosing the appropriate visibility can enhance the security and efficiency of the contract. For instance, sensitive data or functions that should be restricted can be set to private to prevent external access. Conversely, if you want other contracts or wallets to read a variable or call a function, setting it to public is appropriate.