Why struct cannot be inherited

In this article, I'll explain how to use structs in C applications. C struct also known as C structure is a simple user-defined type, a lightweight alternative to a class. A stuct in C is simply a composite data type consisting of a number elements of other types. This article and code examples implements C Structs.

Similar to classes, structures have behaviors and attributes. As a value type, structures directly contain their value so their object or instance is stored on the stack.

C Struts support access modifiers, constructors, indexers, methods, fields, nested types, operators, and properties. Structs are simple to use and can prove to be useful at times. Just keep in mind that they're created on the stack and that you're not dealing with references to them but dealing directly with them. Whenever you have a need for a type that will be used often and is mostly just a piece of data, structs might be a good option.

Structs don't provide inheritance. It is not possible to inherit from a struct and a struct can't derive from any class. Similar to other types in. The following code defines a readonly struct with init-only property setters, available in C 9. Beginning with C 8. If you can't declare the whole structure type as readonly , use the readonly modifier to mark the instance members that don't modify the state of the struct.

Within a readonly instance member, you can't assign to structure's instance fields. However, a readonly member can call a non- readonly member. In that case the compiler creates a copy of the structure instance and calls the non- readonly member on that copy. As a result, the original structure instance is not modified. Typically, you apply the readonly modifier to the following kinds of instance members:. You can also apply the readonly modifier to methods that override methods declared in System.

Object :. If you need to apply the readonly modifier to both accessors of a property or indexer, apply it in the declaration of the property or indexer. The compiler declares a get accessor of an auto-implemented property as readonly , regardless of presence of the readonly modifier in a property declaration. The compiler may make use of the readonly modifier for performance optimizations. For more information, see Write safe and efficient C code. Beginning with C 10, you can use the with expression if you need to mutate immutable properties or fields of a structure-type instance.

A with expression makes a copy of its operand with specified properties and fields modified. You use object initializer syntax to specify what members to modify and their new values, as the following example shows:. When you design a structure type, you have the same capabilities as with a class type, with the following exceptions:.

You can't declare a parameterless constructor. Every structure type already provides an implicit parameterless constructor that produces the default value of the type.

Beginning with C 10, you can declare a parameterless constructor in a structure type. For more information, see the Parameterless constructors and field initializers section.

You can't initialize an instance field or property at its declaration. However, you can initialize a static or const field or a static property at its declaration. Beginning with C 10, you can initialize an instance field or property at its declaration.

A structure type can't inherit from other class or structure type and it can't be the base of a class. However, a structure type can implement interfaces.

You can't declare a finalizer within a structure type. Beginning with C 10, you can declare a parameterless instance constructor in a structure type, as the following example shows:. As the preceding example shows, the default value expression ignores a parameterless constructor and produces the default value of a structure type, which is the value produced by setting all value-type fields to their default values the 0-bit pattern and all reference-type fields to null.

Structure-type array instantiation also ignores a parameterless constructor and produces an array populated with the default values of a structure type. Beginning with C 10, you can also initialize an instance field or property at its declaration, as the following example shows:. If you don't declare a parameterless constructor explicitly, a structure type provides a parameterless constructor whose behavior is as follows:.

Specially because it is ending by a little parenthesis that almost completely invalidates the above definition! Notice from the above that it is all about the interaction model of a variable. It doesn't speculate about storage - heap or stack. On the other side, a struct can be passed by reference by ref or out in C , but whenever you interact with the variable that holds this reference, you cannot change the reference but only the values it points to.

It is statically known and there is no side effects unless the valuetype would implement its own explicit method table management - by using a field that identifies the type of valuetype, in the end, it would look like a class.

When we box a value type, it actually creates a small shell that transform it to a reference type by adding the method table in the header of the shell. Then this struct would only be seen through a reference type an interface or System. What should also be noted is that the definition above doesn't constrain things like inheritance.

In other terms: Value types are not doomed to be excluded from the inheritance folks. There are some cases where inheritance would be quite handy. If I take the example of SharpDX , all COM objects could be declared as inherited struct, where the root main struct would just be a pointer to the COM object and providing the IUnknown interface , and then each derived struct would expose the proper methods for each COM interface.

This is typically where we don't need to have a managed object to represent a native object and most of interop would not need to. It would make the library extremely lightweight in terms of GC pressure, as It would not create any managed object just to wrap a COM object. Unfortunately, this is completely invalid as noted by some comments. An array of value type is simply not cast-able. You can't cast a int[] to short[] or vice et versa, and that would be the same for a StructBase[] vs StructDerived[].

The best you would get is an InvalidCastException , not an undefined runtime behaviour as stated by the answer and this is indeed what I could easily verify while adding support for struct inheritance. The answer takes the example of " Anything storing that struct type would take up a variable amount of memory based on which subtype it ended up containing ".