18.3 Class and struct differences

18.3.1 Value semantics
Structs are value types (§11.1) and are said to have value semantics.
Classes, on the other hand, are reference
types (§11.2) and are said to have reference semantics.
A variable of a struct type directly contains the data of the struct,
whereas a variable of a class type contains
a reference to the data, the latter known as an object.
With classes, it is possible for two variables to reference the same
object, and thus possible for operations on
one variable to affect the object referenced by the other variable. With
structs, the variables each have their
own copy of the data, and it is not possible for operations on one to
affect the other. Furthermore, because
structs are not reference types, it is not possible for values of a struct
type to be null.
[Example: Given the declaration
struct Point
{
public int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
the code fragment
Chapter 18 Structs
269
Point a = new Point(10, 10);
Point b = a;
a.x = 100;
System.Console.WriteLine(b.x);
outputs the value 10. The assignment of a to b creates a copy of the value,
and b is thus unaffected by the
assignment to a.x. Had Point instead been declared as a class, the output
would be 100 because a and b
would reference the same object. end example]
18.3.2 Inheritance
All struct types implicitly inherit from System.ValueType, which, in turn,
inherits from class object. A
struct declaration may specify a list of implemented interfaces, but it is
not possible for a struct declaration
to specify a base class.
Struct types are never abstract and are always implicitly sealed. The
abstract and sealed modifiers are
therefore not permitted in a struct declaration.
Since inheritance isn?t supported for structs, the declared accessibility
of a struct member cannot be
protected or protected internal.
Function members in a struct cannot be abstract or virtual, and the
override modifier is allowed
only to override methods inherited from the type System.ValueType.
18.3.3 Assignment
Assignment to a variable of a struct type creates a copy of the value being
assigned. This differs from
assignment to a variable of a class type, which copies the reference but
not the object identified by the
reference.
Similar to an assignment, when a struct is passed as a value parameter or
returned as the result of a function
member, a copy of the struct is created. A struct may be passed by
reference to a function member using a
ref or out parameter.
When a property or indexer of a struct is the target of an assignment, the
instance expression associated with
the property or indexer access must be classified as a variable. If the
instance expression is classified as a
value, a compile-time error occurs. This is described in further detail in §
14.13.1.
18.3.4 Default values
As described in §12.2, several kinds of variables are automatically
initialized to their default value when
they are created. For variables of class types and other reference types,
this default value is null. However,
since structs are value types that cannot be null, the default value of a
struct is the value produced by
setting all value type fields to their default value and all reference type
fields to null.
[Example: Referring to the Point struct declared above, the example
Point[] a = new Point[100];
initializes each Point in the array to the value produced by setting the x
and y fields to zero. end example]
The default value of a struct corresponds to the value returned by the
default constructor of the struct
(§11.1.1). Unlike a class, a struct is not permitted to declare a
parameterless instance constructor. Instead,
every struct implicitly has a parameterless instance constructor, which
always returns the value that results
from setting all value type fields to their default value and all reference
type fields to null.
[Note: Structs should be designed to consider the default initialization
state a valid state. In the example
using System;
struct KeyValuePair
{
string key;
string value;
C# LANGUAGE SPECIFICATION
270
public KeyValuePair(string key, string value) {
if (key == null || value == null) throw new ArgumentException();
this.key = key;
this.value = value;
}
}
the user-defined instance constructor protects against null values only
where it is explicitly called. In cases
where a KeyValuePair variable is subject to default value initialization,
the key and value fields will be
null, and the struct must be prepared to handle this state. end note]
18.3.5 Boxing and unboxing
A value of a class type can be converted to type object or to an interface
type that is implemented by the
class simply by treating the reference as another type at compile-time.
Likewise, a value of type object or
a value of an interface type can be converted back to a class type without
changing the reference (but of
course a run-time type check is required in this case).
Since structs are not reference types, these operations are implemented
differently for struct types. When a
value of a struct type is converted to type object or to an interface type
that is implemented by the struct, a
boxing operation takes place. Likewise, when a value of type object or a
value of an interface type is
converted back to a struct type, an unboxing operation takes place. A key
difference from the same
operations on class types is that boxing and unboxing copies the struct
value either into or out of the boxed
instance. [Note: Thus, following a boxing or unboxing operation, changes
made to the unboxed struct are not
reflected in the boxed struct. end note]
For further details on boxing and unboxing, see §11.3.
18.3.6 Meaning of this
Within an instance constructor or instance function member of a class, this
is classified as a value. Thus,
while this can be used to refer to the instance for which the function
member was invoked, it is not
possible to assign to this in a function member of a class.
Within an instance constructor of a struct, this corresponds to an out
parameter of the struct type, and
within an instance function member of a struct, this corresponds to a ref
parameter of the struct type. In
both cases, this is classified as a variable, and it is possible to modify
the entire struct for which the
function member was invoked by assigning to this or by passing this as a
ref or out parameter.
18.3.7 Field initializers
As described in §18.3.4, the default value of a struct consists of the
value that results from setting all value
type fields to their default value and all reference type fields to null.
For this reason, a struct does not
permit instance field declarations to include variable initializers.
[Example: As such, the following example
results in one or more compile-time errors:
struct Point
{
public int x = 1; // Error, initializer not permitted
public int y = 1; // Error, initializer not permitted
}
end example]
This restriction applies only to instance fields. Static fields of a struct
are permitted to include variable
initializers.
18.3.8 Constructors
Unlike a class, a struct is not permitted to declare a parameterless
instance constructor. Instead, every struct
implicitly has a parameterless instance constructor, which always returns
the value that results from setting
all value type fields to their default value and all reference type fields
to null (§11.1.1). A struct can declare
instance constructors having parameters. [Example: For example
Chapter 18 Structs
271
struct Point
{
int x, y;
public Point(int x, int y) {
this.x = x;
this.y = y;
}
}
Given the above declaration, the statements
Point p1 = new Point();
Point p2 = new Point(0, 0);
both create a Point with x and y initialized to zero. end example]
A struct instance constructor is not permitted to include a constructor
initializer of the form base(?).
The this variable of a struct instance constructor corresponds to an out
parameter of the struct type, and
similar to an out parameter, this must be definitely assigned (§12.3) at
every location where the
constructor returns. [Example: Consider the instance constructor
implementation below:
struct Point
{
int x, y;
public int X {
set { x = value; }
}
public int Y {
set { y = value; }
}
public Point(int x, int y) {
X = x; // error, this is not yet definitely assigned
Y = y; // error, this is not yet definitely assigned
}
}
No instance member function (including the set accessors for the properties
X and Y) can be called until all
fields of the struct being constructed have been definitely assigned. Note,
however, that if Point were a
class instead of a struct, the instance constructor implementation would be
permitted.
end example]
18.3.9 Destructors
A struct is not permitted to declare a destructor.
18.3.10 Static constructors
Static constructors for structs follow most of the same rules as for
classes. The execution of a static
constructor for a struct is triggered by the first of the following events
to occur within an application
domain:
? An instance member of the struct is referenced.
? A static member of the struct is referenced.
? An explicitly declared constructor of the struct is called.
[Note: The creation of default values (§18.3.4) of struct types does not
trigger the static constructor. (An
example of this is the initial value of elements in an array.) end note]