Understanding Memory and Call Data in Solidity

Memory variables in Solidity are temporary and modifiable, while call data variables are temporary but immutable.

### Understanding Data Locations in Solidity: Memory, Call Data, and Storage
* 📚 In Solidity, the **memory** and **call data** keywords are essential for defining where **temporary variables** are stored during function execution.
* ⚠ If the memory keyword is omitted, compiling will result in an error stating that "**data location must be memory or call data** for parameter in function, but none was given."
* 🔍 Solidity offers six data storage locations: stack, memory, storage, call data, code, and logs, but the focus here is primarily on **memory, call data, and storage**.
* ⏳ Both memory and call data signify **temporary variables** that exist only for the **duration of a function call**, meaning they **cannot be accessed outside of that context**.
* 🔄 The key distinction is that **memory variables can be modified**, while **call data variables cannot be altered once defined**, leading to different use cases in function parameters.
* 🛠 When using structs, mappings, or arrays, the **memory keyword must be specified** for proper functioning, whereas primitive types like uint256 are **managed automatically by Solidity**.
* 📈 Storage variables, on the other hand, are **permanent and exist beyond function calls**, allowing access to their values at any time, as demonstrated with the **favorite number example**.
* ❓ Lastly, it’s important to note that while memory must be specified for certain types, it’s **not required for others**, leading to specific rules about where **data locations can be applied** in Solidity.

you don't have to understand this section fully now. One thing that we didn't really go over and we kind of glossed over was this memory keyword, and you'll notice if we actually delete this keyword and you try to compile, we'll get an error: data location must be memory or call data for parameter in function, but none was given. Now, there are actually six places you can store data in Solidity: the stack, memory, storage, call data, code, and logs. We're not going to go over all of these areas right now, but we are going to go over some of the big ones, which are call data, memory, and storage. And this is going to be a little bit advanced here, so if you don't understand this section the first time, don't worry about it. Just keep pushing through; it'll make more sense as you go later on in the course. All data and memory both mean that this variable is only going to exist temporarily. It's only going to exist for the duration of the function call. Any car anytime we

call add person with a different name. We can only access this name variable that one time that we call this function. If I call add name Patrick seven, and now I try to list of people at zero, obviously, we see Patrick and favorite number seven. We can actually never access that Patrick variable ever again because it existed in memory. It existed for a very short period of time, just for that single call. We could also have call data here, and we'll go ahead and remove this deploy the drop down and do the same thing. We'll add Patrick, and actually, you don't even need the quotes. Patrick will do 88 at person. We'll see if it's in there. Sure is all data and memory, both mean temporary variables inside of functions. Most variables automatically default to memory variables. Strings are a special type in solidity, so you have to specify memory or call data, and it has to do with the way arrays work in memory. But we'll talk about that much later in the course. Now the question obviously then follows, okay, well, if call data and memory are both

temporary variables. Why have two? What's the difference between these two? Well, let's try something. Let's have this be a memory variable, and in here, we'll say name equals cat. So, we're going to reassign whatever people put in here to cat. Let's compile this. Looks like it compiles fine. Now, let's do call data and try to compile. Ah, we get an error. Type error: type literal string 'cat' is not implicitly convertible to expected type string 'call data'. The difference between memory and call data is that a memory variable can be changed. It can be manipulated. If we pass a memory variable to a function, we can go ahead memory, and I hit command s to compile. This is valid Solidity. This is not. If you pass a call data variable, you cannot modify it. Call data is temporary variables that cannot be modified. Memory is temporary variables that can be modified, and storage is permanent variables that can be modified. My favorite number was actually implicitly converted to a storage variable since it's added in this state context outside of a function. If you create a variable

that's outside of any function inside of a contract. It'll automatically be a storage variable. And let's leave this line. Let's compile. Let's deploy again. We'll delete this deploy. We know it's a permanent variable because we can hit retrieve and we can always access what is in favorite number. So if we store one, two, three, we hit store, we can hit retrieve, and we can access one, two, three. So this variable one, two, three exists outside of function calls. Now, even though I said there are more places like stack, code log, return, etc., we can only make these variables call data, memory, or storage. And like I said, we'll explain that later in the course. So let's go ahead, let's add this back to memory because that's normally what you'll see. Now, the next question that logically follows is, Oh, okay, Patrick, well, why do we need to put memory here, but we don't need to put memory over here? In fact, if we try to put memory there, we had an error. Data location can only be specified for array, struct, or mapping.

types, but memory was given. Like I was saying earlier, arrays, structs, or mapping are considered special types in Solidity, and the way that memory management works under the hood makes it so that we have to put this memory keyword. u1-256 is known as a primitive type, and Solidity is smart enough to know where to put this favorite number always under the hood. Like we were saying earlier, a string is actually an array of bytes, and so. So, as we just saw with the error, we need to put the memory keyword for arrays. So, then, next question is, Okay, well, what about the storage variable? Can I put that here? No, you can't put that here either since this is a function. Solidity is smart enough to at least know that, Ah, okay, this is a temporary variable that you're working with. It's got to be memory or call data. It's not going to be storage since this name is only going to exist for a short duration. So, you got to pick one of these other two. So, the summary of this section is that structs, mappings, and arrays need to be given.

this memory keyword string is an array of bytes, so it needs this memory or call data keyword.

Lesson 2 Part 7 | Memory, Storage, Calldata - Solidity & Foundry Full Course

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


Cyfrin Audits

Memory and call data are both temporary variable types in Solidity, but they serve different purposes.

Memory variables can be changed and manipulated, while call data variables cannot be modified.

Storage variables, on the other hand, are permanent and can be modified, with the context outside of a function implicitly converting them to storage.

Understanding Storage Variables in Contracts

Storage variables in contracts are permanent and accessible outside of function calls.

The variable's data can be retrieved and stored, demonstrating its persistent nature.

Memory location is only necessary for array, struct, or mapping variables, which is why it cannot be specified for other variable types.

In Solidity, special types like arrays, structs, and mappings require the use of the memory keyword due to their unique memory management.

Primitive types, such as u1-256, are handled automatically by Solidity.

Temporary variables in functions cannot use storage, so they must be designated as either memory or call data.

Solidity has six data storage options: stack, memory, storage, call data, code, and logs.

The memory and call data keywords are essential for temporary variable storage during function calls.

Understanding these storage areas may be advanced, but it's important to grasp their significance as you progress through the course.