• DEFINATION
• Why we use Memory inside the functions for reference types ?

When you call a setter function it creates a transaction that needs to be mined and costs gas because it changes the blockchain.

• This is because state variables are stored in contract storage, which is a permanent and persistent data store on the blockchain. When you change a state variable, you are essentially changing the state of the contract, which requires a transaction to be submitted to the network. This transaction must be mined and validated by the network before the change to the state variable is finalized.

When you declare a public state variable a getter function is automatically created.

• This is because getter functions are used to read the value of state variables. When you declare a public state variable, the Solidity compiler automatically generates a getter function that can be used to read the value of the variable from outside the contract.

By default variable visibility is private.

• This means that state variables are private by default. This is a good security practice, as it prevents unauthorized users from reading and writing to the state of the contract.
• Here are some additional points about state variables in Solidity:
• State variables can be declared inside or outside of functions. However, it is generally considered best practice to declare state variables

Solidity - View and Pure Functions - GeeksforGeeks

Benefits of Using View and Pure Functions 💡

1️⃣ Security: By explicitly declaring functions as view or pure, you provide clarity to other developers and auditors regarding the intended behavior of the function. This helps prevent unintentional modifications to the state and minimizes the risk of introducing vulnerabilities.

2️⃣ Gas Efficiency: View and pure functions do not require transactions to be executed on the blockchain. As a result, they do not consume any gas, making them more cost-effective when retrieving data or performing computations.

3️⃣ Code Reusability: View and pure functions can be called by other functions within the same contract or by external contracts. This promotes code reusability and modular design, as these functions can be used in multiple contexts without concerns about state modifications.

4️⃣ Optimization: Since pure functions are entirely self-contained and do not rely on external variables, they can be optimized by the compiler more aggressively. This can lead to improved performance and reduced gas costs.