Pointers and references: Difference between revisions
→{{header|Kotlin}}
(linked page to Memory Allocation, which makes sense.) |
|||
Line 730:
Java is call-by-value. When passing arguments, you are either passing primitives by value or references by value. There is no such thing as "passing an object" as objects are not values in the language. As noted above, if the object that the reference is pointing to is mutable, then it is possible to modify that object's state through the reference. Then if the calling function has a reference to the same object, they will see that modification through the reference. So if you want to reflect changes in an argument back to the caller, one thing that you can do is wrap the argument as a field in an object, then modify the object through the reference.
=={{header|Julia}}==
Like Python, Julia's native variables and data types are accessed via references. Julia does have pointers, but they are mainly used for interfaces with other languages, especially C, that use pointers.
Julia's C interface pointer functions are considered "unsafe" because, like C pointers, they may cause data corruption if used incorrectly.
<lang julia>x = [1, 2, 3, 7]
parr = pointer(x)
xx = unsafe_load(parr, 4)
println(xx) # Prints 7
</lang>
=={{header|Kotlin}}==
Line 811 ⟶ 825:
2
</pre>
=={{header|M2000 Interpreter}}==
There are three kind of pointers, and two kind of references. Pointers can change, but reference can't change. There are no arithmetic operations to pointers. We can operate for objects that points. References are never nil, but weak references maybe invalid. There is a special container (an object) named Buffer for handling memory blocks and we can get addresses from that and use them to call code (we can make memory blocks for code execution too). So using buffers for data and buffers for code we can use pointers as those in assembly. Also we can use external dll, and pass them addresses too.
| |||