Data Location Assignment

[mvrpraveen]

Hi,

Following is my solution to the data location assignment:

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 memory user = users[id];
         users[id].balance = balance;
    }

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

}

[crypto-djent76]

Hey Jon,

That is very true and has helped me with other subjects that I am or have learned.
Again, I appreciate the feedback

[Anvar_Xadja]

Hello guys! This is one code change solution lol. I think most obvious and easy way

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;
    }

}

[jon_m]

Nice solution @ibn5x

Even though the initial idea of this assignment is to update the existing balance by replacing it with the new one, I actually think that it makes more sense to do what you have done, and add an amount to the existing balance using the addition assignment operator += (instead of the assignment operator = ). However, if you add to, instead of replacing, the existing balance, I think your code would be clearer and more readable if you also change the name of the balance parameter to amount , because you are adding an amount to the balance, rather than replacing it with a new balance.

Let me know if you have any questions

[ibn5x]

Hey Thanks, @jon_m Happy accident that I misinterpreted the assignment then I guess. No questions for you now, your response makes total sense and has been dutifully noted. I appreciate your time.

[Zaqoy]

Hi, here is my code! Thanks.

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;
    }

}

[Unknowncode]

pragma solidity ^0.8.1;
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;
    }

}

I changed memory to storage and also change user.balance=balance to user.balance += balance;

[ZacSed]

users[id].balance = balance;

the issue with the original code is that the balance was stored in memory, i.e. as a temporary data type because the ‘balance’ amount was set to a memory data type, not a permanent data type, i.e. not the storage data type.

[KK_Cheah]

Thank you so much for the code review @jon_m. Incredible insight and valuable information on what are the thought process of a much more proficient Solidity programmer when it comes to generating a smart contract. Really appreciate the reply and all the constructive criticism. Looking forward from more guidance from you.

[RBeato]

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 memory user = users[id];
    //  user.balance = balance;
    
    //SOLUTION 1
     User memory user = users[id];
     user.balance = balance;
     users[id] = user;
    
    //SOLUTION 2
    users[id] = User(id, balance);

     //SOLUTION 3
     User user = users[id];
     user.balance = balance;
     users[id] = user;
}

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

}

[jon_m]

Nice solution @Unknowncode
… and good to see you back here in the forum I hope you’re enjoying the course!

Even though the initial idea of this assignment is to update the existing balance by replacing it with the new one, I actually think that it makes more sense to do what you have done, and add an amount to the existing balance using the addition assignment operator += (instead of the assignment operator = ). However, if you add to, instead of replacing, the existing balance, I think your code would be clearer and more readable if you also change the name of the balance parameter to amount , because you are adding an amount to the balance, rather than replacing it with a new balance .

Let me know if you have any questions

[jon_m]

Nice solution @ZacSed

Just be careful with the term data type. This refers to whether data is defined as uint, int, address, bool, string etc. Here you are highlighting differences in the duration data is stored for (either temporarily, or persistently). This is a result of data location (memory, or storage), and not data type.

Let me know if you have any questions

[jon_m]

Hi @RBeato,

@RBeato

  //SOLUTION 1
   User memory user = users[id];
   user.balance = balance;
   users[id] = user;

Correct… although not very efficient in terms of gas cost or conciseness of code.

@RBeato

  //SOLUTION 2
   users[id] = User(id, balance);

This solution makes the updateBalance function exactly the same as the addUser function.
While this does still work…

@jon_m

If we have two functions that perform exactly the same operation, that’s not efficient, and so in this case we might as well remove one of the functions and just call the remaining one something more general, such as update().

However, this is hardly ideal. So what you want to aim for with the updateBalance function, is code that only updates the balance property for a particular user ID, and not the whole User instance. We only need to create a whole new User instance when we add a new user, because once added, their user ID won’t need to change (at least not at the same time as their balance).

@RBeato

  //SOLUTION 3
   User user = users[id];
   user.balance = balance;
   users[id] = user;

This is incorrect: the first line generates a red compiler error. The error message tells you what the specific nature of the error is: the data location for this complex data type (a User instance based on the User strut) must be explicitly declared for local variables.

Have you now found out what the 2 most efficient solutions are? If not, you will find them in other students’ solutions posted in this discussion topic.

Let us know if anything is unclear, or if you have any questions

[TolgaKmbl]

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 newBalance) public {
         users[id].balance = newBalance;
    }

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

}

[RBeato]

Thank you! I got it!

[Eerina_Haque]

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;
    }

}

[mike_sutanto]

Hi guys, I figured that the problem in the starter code was that it was using a memory located temporary variable to assign the new balance value, so the fix was just simply using dot notation to directly access the users mapping (located in storage) and change the balance value of the user permanently.

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]

Nice solution, and a very good explanation @mike_sutanto

[BShehaj]

pragma solidity 0.8.1;
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;
}

}

[luiscal89]

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;
}

}