awesome now let's say you really like this simple storage contract you love all the functionality except for one thing you wish that the store function didn't just store the favorite number you wished it added five so for some reason you want a contract that does everything this contract does but just

adds five whenever you call store for some reason you want everyone's favorite number to be five larger than what they think it is well one thing we could do is we could just copy paste this into a new file but again that's kind of too much work for me I'm a lazy engineer but

let's go ahead and see how we can approach this problem so let's create a new file and we'll call it add five storage that's all and same thing since this is a new contract we're going to follow the exact same tips we're gonna

do SPDX license identifier MIT we're gonna do pragma solidity 0.8.18 let's even do the little carrot here and we'll do contract add five storage like so click compile great looking good oh I'm getting a warning SPDX license it's about license wrong so

let's spell that right okay cool looks good so like I said the first thing that we could do is we could copy paste everything in here and then just change the pieces that we don't like in our add5 storage this is a little bit redundant a

little bit too much work and we are Engineers we want to work as hard as possible to be as lazy as possible so how can we do that well this is where we can do something called inheritance we can have our add 5 storage contract be

something called a child contract of our simple storage contract and we can have our add5 storage inherit all of the functionality all of the functionality of our simple storage contract. So first of course, in order for our add5 storage to know about our simple storage

contract, we're going to go ahead and have to import it. So we're going to do import and we're going to do once again the named imports because we're advanced Solidity engineers. So we're going to say import simple storage, just the simple storage contract from

dot slash simplestorage.sol. Now if this dot slash is confusing to you, don't worry. We'll learn about directory structures later on in the course. And then we'll say our contract add5 storage is simple storage. Now our add5 storage is going to do what's called

inherit everything from simple storage and our add5 storage is going to have all the same functionality as simple storage. We can actually see this directly if we go to compile. Let's go ahead and delete our previously deployed contracts. We're on the Remix VM. Let's make sure we're

we've selected add5 storage, ad5storage.sol. Let's go ahead and deploy it. And if we scroll down, we can actually see, oh my goodness, it's got all the same buttons as simple storage even though the contract itself doesn't have anything defined. That's because we

inherited all the buttons. We inherited all the functionality of simple storage into add5 storage. If you want a contract to inherit the functionality of another contract, you just import it in and then say your contract is that other contract. Now we can keep going though and add our own

custom functionality into ad5 storage that's not in simple storage so for example we could say function say hello it's going to be public and it returns a string memory and again you need the memory keyword because strings are special in solidity we just say return

hello like so this will be a public function it's not a view because we're not reading from storage and again if that description is a little confusing to you don't worry too much about it now but if we go to deploy it let's delete our old

one we'll deploy this one we see we have all the functionality of simple storage plus this say hello function great well let's delete that for now let's say instead of wanting to add additional customization you actually love every function in here except for one remember

the reason we wanted this add5 storage.sol is because we actually want to change the store function to have it add an additional five to people's favorite numbers maybe you're mischievous and you want people's favorite numbers to be five greater than

they are well to add this add 5 customization to that store function we could do something called overrides to do overrides there are two keywords that we need to be aware of those are virtual and override if I were to try to create a store function for our ad5 storage

right now what do you think will happen let's try it out so let's say function store uint256 underscore newNumber public if we try to compile this right now we'll actually get an error even if there's nothing in this store function we roll over we say from solidity type

error overriding function is missing override specifier and remember if you get lost or confused an error like this is something perfect for you to ask ChatGPT or maybe even find, we could say "I am trying to compile my solidity code but I'm getting this error." We can copy

this whole error here, paste it in here and then in additional context we'll just add the code like this, we'll hit search, see what it gives us. We'll say, and it looks like Find was able to find the answer. The error message indicates the functions store in the ad5

storage contract is missing the override specifier which is required because it overrides a virtual function from the SimpleStorage contract. Thanks! I'll explain what Find is giving us in just a minute. It's right, we need to tell Solidity that it needs to override the store function in SimpleStorage.

We want to be very explicit and say, "Hey, do this store function and not what's in CivilStorage.sol." So let's go ahead and add the keyword override. Now though, if we just have that keyword, we go ahead and try to compile, we still get an error.

Trying to override a non-virtual function. Did you forget to add virtual? In order for a function to be overridable, you need to add this virtual keyword in the base class or the parent class. So in SimpleStorage, we need to add virtual to store. This virtual

keyword means that this function is overridable. Any function that doesn't have this keyword, you can't override. Now our store function is overridable and we've specified that we are indeed going to override the store function. Now if we go ahead and compile, we'll see

everything compiles successfully all right great so now let's just add the functionality to store remember since ad5 storage inherits everything from simple storage this means that we even have access to my favorite number so what we can do is we can say my favorite

number equals underscore new number plus five we'll compile this and now let's try it out we're on remix VM we want to make sure we're with ad5 storage we'll delete the other ones we'll deploy scroll down hit the drop down retrieve

currently return zero now if we store two we'll pull up the terminal to make sure we're actually sending transactions we'll hit store and now if we hit retrieve we see we indeed get seven back because two plus five is seven we add five we hit store retrieve now returns

ten So This Is How We Do inheritance and override functions

Lesson 3 Part 7 | Inheritance - Solidity & Foundry Full Course

Book a smart contract audit here 👇
https://www.cyfrin.io/


Cyfrin Audits

Introducing the problem and initial approach

Desire to modify a simple storage contract to add 5 to the stored number.

Copying and pasting the contract is deemed inefficient.

Creating a new contract named 'add five storage'.

Setting up the new contract with SPDX license and pragma.

Using inheritance to avoid redundant code.

Using named imports for better code organization.

'add5 storage' inherits functionality from 'simple storage'.

Verification of inherited functionality through compilation and deployment.

Adding custom functionality through inheritance

Adding a new 'sayHello' function to the inherited contract.

Explanation of public functions and the 'memory' keyword for strings.

Deployment and verification of the new function.

Overriding functions with 'virtual' and 'override'

The goal is to modify the 'store' function to add 5 to the stored number.

Introduction of 'virtual' and 'override' keywords.

Error handling and using ChatGPT for troubleshooting.

Explanation of the error and the need for 'override' and 'virtual' keywords.

Adding 'virtual' to the parent function and 'override' to the child function.

Modifying the 'store' function to add 5 to the number.

Deployment and testing of the modified function on Remix IDE.