In certain computer programming languages, data types are classified as either value types or reference types, where reference types are always implicitly accessed via references, whereas value type variables directly contain the values themselves.[1][2]
Even among languages that have this distinction, the exact properties of value and reference types vary from language to language, but typical properties include:
int |
(a value type) into an
Integer |
object (an object type), or reversing this via "unboxing".
Even when function arguments are passed using "call by value" semantics (which is always the case in Java, and is the case by default in C#), a value of a reference type is intrinsically a reference; so if a parameter belongs to a reference type, the resulting behavior bears some resemblance to "call by reference" semantics. This behavior is sometimes called call by sharing.
Call by sharing resembles call by reference in the case where a function mutates an object that it received as an argument: when that happens, the mutation will be visible to the caller as well, because the caller and the function have references to the same object. It differs from call by reference in the case where a function assigns its parameter to a different reference; when that happens, this assignment will not be visible to the caller, because the caller and the function have separate references, even though both references initially point to the same object.
Many languages have explicit pointers or references. Reference types differ from these in that the entities they refer to are always accessed via references; for example, whereas in C++ it's possible to have either a
std::string
and a
std::string *
, where the former is a mutable string and the latter is an explicit pointer to a mutable string (unless it's a null pointer), in Java it is only possible to have a
StringBuilder |
, which is implicitly a reference to a mutable string (unless it's a null reference).
While C++'s approach is more flexible, use of non-references can lead to problems such as object slicing, at least when inheritance is used; in languages where objects belong to reference types, these problems are automatically avoided, at the cost of removing some options from the programmer.
Language | Value type | Reference type |
---|---|---|
Java[3] | all non-object types, including (e.g.) booleans and numbers | all object types, including (e.g.) arrays |
C#[4] | all non-object types, including structures and enumerations as well as primitive types | all object-types, including both classes and interfaces |
Swift[5][6] | structures (including e.g. booleans, numbers, strings, and sets) and enumerations (including e.g. optionals) | functions, closures, classes |
Python[7] | all types | |
JavaScript[8] | all non-objects, including booleans, floating-point numbers, and strings, among others | all objects, including functions and arrays, among others |
OCaml[9][10] | immutable characters, immutable integer numbers, immutable floating-point numbers, immutable tuples, immutable enumerations (including immutable units, immutable booleans, immutable lists, immutable optionals), immutable exceptions, immutable formatting strings | arrays, immutable strings, byte strings, dictionaries |
Original source: https://en.wikipedia.org/wiki/Value type and reference type.
Read more |