A struct type
is a value type that is typically used to encapsulate small groups of related
variables, such as the coordinates of a rectangle or the characteristics of an
item in an inventory.
It is suitable
for representing lightweight objects such as Point, Rectangle,
and Color.
For example, if you declare an array of 1000 Point objects, you will allocate additional memory for referencing
each object; in this case, a struct would be less expensive.
public struct CoOrds
{
public int x, y;
public CoOrds(int p1, int p2)
{
x = p1;
y = p2;
}
}
It is an error to
define a default (parameterless) constructor for a struct, because the instance
can be created for Struct without 'new' keyword, and at that time, placing the
default parameter go meaningless.
It is also an error to initialize an instance field in a struct body. You can initialize struct members only by using a parameterized constructor or by accessing the members individually after the struct is declared.
Any private or otherwise inaccessible members can be initialized only in a constructor.
When you create a
struct object using the new operator,
it gets created and the appropriate constructor is called.
When a struct contains
a reference type as a member, the default constructor of the member must be
invoked explicitly, otherwise the member remains unassigned and the struct
cannot be used. (This results in compiler error CS0171.)
-----------------------------------
public struct Struct1
{
public string s = "abc"; // this throws error
}
-----------------------------------
public struct Struct1
{
public static string s = "abc"; // this works
}
----------------------------------
public struct Struct1
{
public string s;
public Struct1(int b)
{
s = "dds"; //
this works
}
}
----------------------------------
There is no
inheritance for structs as there is for classes. A struct cannot inherit from
another struct or class, and it cannot be the base of a class.
Structs, however, inherit from the base class Object. A struct can implement interfaces, and it does that exactly as classes do.
Structs can also contain constructors, constants, fields, methods, properties, indexers, operators, events, and nested types, although if several such members are required, you should consider making your type a class instead.
Structs can implement an interface but they cannot inherit from another struct. For that reason, struct members cannot be declared as protected.
This example
demonstrates struct initialization using both default and
parameterized constructors.
public struct CoOrds
{
public int x, y;
public CoOrds(int p1, int p2)
{
x = p1;
y = p2;
}
}
// Declare and
initialize struct objects.
class TestCoOrds
{
static void Main()
{
//
Initialize:
CoOrds coords1 = new CoOrds();
CoOrds coords2 = new CoOrds(10, 10);
//
Display results:
Console.Write("CoOrds 1: ");
Console.WriteLine("x = {0}, y = {1}",
coords1.x, coords1.y);
Console.Write("CoOrds 2: ");
Console.WriteLine("x = {0}, y = {1}",
coords2.x, coords2.y);
//
Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
/* Output:
CoOrds 1: x = 0, y = 0
CoOrds 2: x = 10, y = 10
*/
Unlike classes,
structs can be instantiated without using the new operator. In
such a case, there is no
constructor call,
which makes the allocation more efficient. However, the fields will remain
unassigned and the object cannot be used until all of the fields are
initialized.
This example
demonstrates a feature that is unique to structs. It creates a CoOrds object
without using the new operator. If you replace the word struct with
the wordclass, the program will not compile.
public struct CoOrds
{
public int x, y;
public CoOrds(int p1, int p2)
{
x = p1;
y = p2;
}
}
// Declare a struct
object without "new."
class TestCoOrdsNoNew
{
static void Main()
{
//
Declare an object:
CoOrds coords1;
//
Initialize:
coords1.x = 10;
coords1.y = 20;
//
Display results:
Console.Write("CoOrds 1: ");
Console.WriteLine("x = {0}, y = {1}",
coords1.x, coords1.y);
//
Keep the console window open in debug mode.
Console.WriteLine("Press any key to exit.");
Console.ReadKey();
}
}
// Output: CoOrds 1: x =
10, y = 20
No comments:
Post a Comment