Solidity Reference Passing – How to Pass By Reference in Solidity

assemblycontract-deploymentcontract-designcontract-developmentsolidity

I have a couple of questions.

First:

So, In a function, i created memory array. I want to pass this memory by reference to another function..

function test2() public returns(uint  a) {
        uint[2] memory gio;
        gio[0] = 100;
        gio[1] = 200;
        test3(gio);
        return gio[0];
    }
    
    
    function test3(uint[2] storage arr) private returns (uint) {
        arr[0] = 35;
    }

This doesn't work and says:

Invalid type for argument in function call. Invalid implicit
conversion from uint256[2] memory to uint256[2] storage pointer
requested. test3(gio); ^-^

Is it not possible ?

Second

internal and private functions are the only types of functions that can receive parameters as reference types, right ? since public and external functions being called could be dependent on another application, so another app can't pass parameters as references. Agreed ?

Third.

string test;
   
    function test2() public returns(uint  a) {
        test = " awesome ";
        test3(test);
        return 10;
    }
    
    
    function test3(string storage str) private  {
        str = " changed ";
    }

Why does calling test2 result in:

TypeError: Type literal_string " changed " is not implicitly
convertible to expected type string storage pointer. str = " changed
"; ^———^

Best Answer

When you declare a parameter as storage you are limiting the function to only accept parameters with that qualifier.

The qualifiers storage, memory and calldata specify where the data is located. You can convert implicitly storage to memory and calldata to memory, but the reverse is not possible.

string public stor = "banana";

function test(string calldata calld) external view {
    string memory memo = "pizza";

    foo(memo, stor);
    foo(calld, stor);  // Creates a copy of calld in memory and passes as parameter
    foo(stor, stor);   // Creates a copy of stor in memory and passes as parameter
    
    foo(memo, stor);
    // foo(memo, memo); // Cannot convert from memory to storage
    // foo(memo, calld); // Cannot convert from calldata to storage
}

function foo(string memory, string storage) internal view {
    
}

/* This fails because you can only use calldata on external functions
function bar(string calldata) internal view {
    
} */

Value types like bool, uintXXX, bytesYY, address, etc. are passed by value. Non-value tyeps like structs, arrays, string are passed by reference.

Functions that are public, internal and private can use types passed by reference but only if they are call from the same contract.
Functions public and external will receive a copy when called by a regular user of from another contract.

I don't know why, but at least since solc 0.3 it wasn't allowed.

Related Solutions

Solidity Conversion – Parse an Integer to a String in Solidity

try this code :

function bytes32ToString (bytes32 data) returns (string) {
    bytes memory bytesString = new bytes(32);
    for (uint j=0; j<32; j++) {
      byte char = byte(bytes32(uint(data) * 2 ** (8 * j)));
      if (char != 0) {
        bytesString[j] = char;
      }
    }

    return string(bytesString);
  }

   function My_integ(bytes32 myInteger) returns (string){

        string memory myString= bytes32ToString( myInteger );
return myString;
   }

solidity – Passing Strings by Reference in Solidity Smart Contracts

The string is a reference type in Solidity and references are passed by value or copied when specified as any function's argument. Think of objects in Javascript which show no changes in calling function when they are re-assigned in the called function, but any update of its properties does reflect the change. This reference is different from pointers in other languages that can be directly dereferenced with asterisk * to change the contents at pointed location in memory.

In the first case, the memory reference is reassigned, hence the change is reflected only local to the function as string's memory reference was copied. The only changes that are reflected in the calling function are when some property on the received reference is updated (like a property of struct or index of an array), but when a reference is reassigned, it points to a new memory location and the original reference in calling function remains unchanged. string type does not have any property and neither it can be updated through index but if you utilize bytes type then you can see the behavior where we are able to update properties on references which in the following case is indexes of array. But if you re-assign bytes reference then the calling function shows no changes.

contract Test {
    
    function testing() public pure returns (string memory) {
        string memory x = "Hello";
        callOtherFunction(bytes(x));

        return string(x);
    }

    function callOtherFunction(bytes memory x) internal pure {
        x[0] = bytes1('W');
        x[1] = bytes1('o');
        x[2] = bytes1('r');
        x[3] = bytes1('l');
        x[4] = bytes1('d');
    }
}

The second case is showing the same behavior, the difference is just that the Solidity compiler does not allow reassigning references pointing to contract's storage. Although, you can still update properties on the storage pointer.

contract Test {

    string public state_x = "Hello";

    function testingShit() public {
        callOtherFunction(bytes(state_x));
    }

    function callOtherFunction(bytes storage x) internal {
        x[0] = bytes1('W');
        x[1] = bytes1('o');
        x[2] = bytes1('r');
        x[3] = bytes1('l');
        x[4] = bytes1('d');
    }
}

Best Answer

Related Solutions

Solidity Conversion – Parse an Integer to a String in Solidity

solidity – Passing Strings by Reference in Solidity Smart Contracts

Related Topic