Data Location Assignment [OLD]

[jon_m]

Hi @Carlosvh96,

@Carlosvh96

had to copy the answer from this thread
and had a hard time understanding some stuff, i definetely need to practice more,before continuing with the course, anyways

Do let us know if there is anything you still don’t understand and we’ll do our best to explain it in a way that helps you You’re doing the right thing by trying to practise more, as some of these concepts only “click” after working through some more examples. You’ll come across lots more examples as the course progresses, so don’t worry if there are still a few loose ends, as you’ll find these get tied up later on. But do let us know if there is anything major you are struggling with.

@Carlosvh96

as we all already know:

function updateBalance(uint id, uint balance) public {
User memory user = users[id];
user.balance = balance;
}
this only updates the balance momentarily and then after the function finishes working, the new data disappears, and also it is redundant

That’s right. It’s redundant because we don’t do anything with the new balance stored only temporarily as a property of the local user variable.

@Carlosvh96

as it states info that was already stated in the updateBalance function

This is the original code that you had to change, so there is no repetition here, it’s just incorrect and, as you say, redundant…pointless. We could just replace memory with storage, and that would solve the problem, but this would be less concise, and perhaps this is what you mean.

@Carlosvh96

with the corrected version we kill two birds with one stone, making the code shorter and and making it actually do what we wanted it to.

That’s absolutely correct. The version you chose does exactly that

@Carlosvh96

i chose the one that goes:

  function updateBalance(uint id, uint balance) public{
     users[id].balance = balance;
}

[jon_m]

Hi @RojasMessilia and @niore,

@RojasMessilia

function updateBalance(uint id, uint balance) public {
     User memory user = users[id];
     user.balance = balance;
     users[id] = user;
}

@niore

  function updateBalance(uint id, uint balance) public {
         User memory user = users[id];
         user.balance = balance;
         users[id] = user;
    }

This alternative solution is correct, but is very long-winded, repetitve and not very concise. It also consumes more gas and so will be more expensive than the following solution…

 function updateBalance(uint id, uint balance) public {
         users[id].balance = balance;
    }

As you can see this alternative is also more concise. I like @Carlosvh96’s comment about this solution…

@Carlosvh96

… we kill two birds with one stone, making the code shorter and and making it actually do what we wanted it to.

[jon_m]

Hi @niore,

@niore

function updateBalance(uint id, uint balance) public {
         balance[id].balance = balance;
    }

This is incorrect, I think you may have meant…

 users[id].balance = balance;
// users[id].balance instead of balance[id].balance

This would be correct, because the mapping name is users.

[jon_m]

Excellent analysis and edit @tnc

@tnc

users[id].balance = balance;

… is definitely more concise (which is why I prefer it, by the way). Perhaps that’s a better way of describing it than…

@tnc

the most efficient

… because they both consume about the same amount of gas.

[jon_m]

Nice solution and analysis @Paul_Mun

Just a couple of observations…

@Paul_Mun

So the solution I found was to change the stored data type from memory to storage.

What you are changing here isn’t the data type but the data location.
Data types are uint, int, bool, string etc. The actual data type here is User (a struct instance).

@Paul_Mun

… was trying to access the specific User from the User struct …

The specific user is an instance of the User struct, yes, but it’s stored in the mapping, and so it’s the mapping we need to access and update, not the struct.

[jon_m]

Nice solution @cmeronuk
… and welcome to the forum! It’s good to see you here, and I hope you’re enjoying the course

Just a couple of comments about the terminology:

@cmeronuk

Updated code to comment out memory modifier

@cmeronuk

//User memory user = users[id];

This is a local variable, with the name user, and stored temporarily in memory (its data location). It isn’t a modifier.

[jon_m]

Nice solution @Andro

@Andro

It is a bit confusing to navigate between the values and variables that are named so similarly: user, User, users

Yes, I totally agree! So, well done for persevering!

@Andro

whatever is stored in memory is gone after the function (addUser) is executed.

… don’t you mean after the updateBalance function is executed? The addUser function updates the mapping (with the new User instance) directly, and doesn’t declare a local variable to store data temporarily in memory. It’s the updateBalance function which initially did that.

[tnc]

Good points!
Now that I now that the when you set a variable you get a pointer and not a copy it makes sense that is not most efficient.

[Paul_Mun]

Ahh ok I see what you mean, that makes complete sense! Thank you for the clarification on this.

[Gorana]

pragma solidity 0.7.5;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     User storage user = users[id];
     user.balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

or

pragma solidity 0.7.5;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
     users[id].balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[Andro]

@jon_m

… don’t you mean after the updateBalance function is executed?

Thanks for answering. Yes, that’s exactly what I meant, I must have copied the wrong function name.

[ArtCenter1]

pragma solidity 0.7.5;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
    users[id].balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[inahan]

pragma solidity 0.7.5;
contract MemoryAndStorage {

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
         users[id].balance=balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[jon_m]

Hi @tnc,

You only create a pointer to a value (instead of a copy of that value) when you assign a value stored in storage (in a state variable) to a local variable declared with storage. Creating a pointer consumes less gas than creating a copy. You create a temporary copy of a value stored in storage when you assign it to a local variable declared with memory, and this consumes more gas.

//That's why...
User storage user = users[id];
user.balance = balance;
// actually consumes about the same amount of gas as
users[id].balance = balance;

[Caspian1234]

Updated the User local variable data storage location from memory to storage to ensure that values were being updated in the same location and would persist after the updateBalance function had been executed.

User memory user = user[id] >>>> User storage user = user[id]

[Depth-Hoar]

Change memory to storage so you can add on to the contract over time. If it is uses memory it is like everything starts fresh every time the contract is used.

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         User storage user = users[id];
         user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[LiewJunXian]

pragma solidity 0.5.12;

contract MemoryAndStorage{

mapping(uint => User) users;

struct User{
    uint id;
    uint balance;
}

function addUser(uint id, uint balance) public {
    users[id] = User(id, balance);
}

function updateBalance(uint id, uint balance) public {
    User storage user = users[id];
    user.balance = balance;
}

function getBalance(uint id) view public returns (uint) {
    return users[id].balance;
}

}

[Timmy]

In the updateBalance function you need to change the users[id].balance = balance; to
User storage user = users[id];
user.balance = balance;
Memory is a temporary place to store data whereas Storage holds data between function calls.

pragma solidity 0.7.5;

contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
        User storage user = users[id];
        user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[seer]

The updateBalance() function was loading the User into the memory and updated the balance in this memory version of the object, but never persisted it back into storage. I went for the easiest way and updated the balance straight into the mapping in Storage without the need to load it into memory first.

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
         users[id].balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

[Bobcat]

pragma solidity 0.7.5;
contract MemoryAndStorage {

    mapping(uint => User) users;

    struct User{
        uint id;
        uint balance;
    }

    function addUser(uint id, uint balance) public {
        users[id] = User(id, balance);
    }

    function updateBalance(uint id, uint balance) public {
        User storage user = users[id];
        user.balance = balance;
    }

    function getBalance(uint id) view public returns (uint) {
        return users[id].balance;
    }

}

In this code above I adjusted the “user” object to store its data within the Storage and not within the Memory, as the memory is temporary and the information is lost once the function exists.