cerc-io/solidity
10
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #8089 from ethereum/array-copy

Browse Source 
[DOCS] Clarify array copying semantics
This commit is contained in:
chriseth 2020-02-20 16:15:17 +01:00 committed by GitHub
commit cc55daae55
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 2 additions and 12 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
docs/control-structures.rst
View File

@ -343,18 +343,8 @@ i.e. the following is not valid: ``(x, uint y) = (1, 2);``
Complications for Arrays and Structs Complications for Arrays and Structs
------------------------------------ ------------------------------------
The semantics of assignments are a bit more complicated for The semantics of assignments are more complicated for non-value types like arrays and structs,
non-value types like arrays and structs. including ``bytes`` and ``string``, see :ref:`Data location and assignment behaviour <data-location-assignment>` for details.
Assigning *to* a state variable always creates an independent
copy. On the other hand, assigning to a local variable creates
an independent copy only for elementary types, i.e. static
types that fit into 32 bytes. If structs or arrays (including
``bytes`` and ``string``) are assigned from a state variable
to a local variable, the local variable holds a reference to
the original state variable. A second assignment to the local
variable does not modify the state but only changes the
reference. Assignments to members (or elements) of the local
variable *do* change the state.
In the example below the call to ``g(x)`` has no effect on ``x`` because it creates In the example below the call to ``g(x)`` has no effect on ``x`` because it creates
an independent copy of the storage value in memory. However, ``h(x)`` successfully modifies ``x`` an independent copy of the storage value in memory. However, ``h(x)`` successfully modifies ``x``