为什么我们需要结构？ （C＃）

Question

To use a struct, we need to instantiate the struct and use it just like a class. Then why don't we just create a class in the first place?

Answer 1

struct是一个值类型，所以如果你创建一个副本，它实际上会物理复制数据，而对于一个类，它只会复制对数据的引用

Answer 2

A major difference between the semantics of class and struct is that struct s have value semantics. What is this means is that if you have two variables of the same type, they each have their own copy of the data. Thus if a variable of a given value type is set equal to another (of the same type), operations on one will not affect the other (that is, assignment of value types creates a copy). This is in sharp contrast to reference types.

There are other differences:

1. Value types are implicitly sealed (it is not possible to derive from a value type).
2. Value types can not be null .
3. Value types are given a default constructor that initialzes the value type to its default value.
4. A variable of a value type is always a value of that type. Contrast this with classes where a variable of type A could refer to a instance of type B if B derives from A .

Because of the difference in semantics, it is inappropriate to refer to struct s as "lightweight classes."

Answer 3

In C#, a struct is a value type, unlike classes which are reference types. This leads to a huge difference in how they are handled, or how they are expected to be used.

You should probably read up on structs from a book. Structs in C# aren't close cousins of class like in C++ or Java.

Answer 4

All of the reasons I see in other answers are interesting and can be useful, but if you want to read about why they are required (at least by the VM) and why it was a mistake for the JVM to not support them (user-defined value types), read Demystifying Magic: High-level Low-level Programming . As it stands, C# shines in talking about the potential to bring safe, managed code to systems programming. This is also one of the reasons I think the CLI is a superior platform [than the JVM] for mobile computing. A few other reasons are listed in the linked paper.

It's important to note that you'll very rarely, if ever, see an observable performance improvement from using a struct. The garbage collector is extremely fast, and in many cases will actually outperform the structs. When you add in the nuances of them, they're certainly not a first-choice tool. However, when you do need them and have profiler results or system-level constructs to prove it, they get the job done.

Edit: If you wanted an answer of why we need them as opposed to what they do, ^^^

Answer 5

This is a myth that struct are always created on heap. Ok it is right that struct is value type and class is reference type. But remember that

1. A Reference Type always goes on the Heap.
2. Value Types go where they were declared.

Now what that second line means is I will explain with below example

Consider the following method

  public void DoCalulation()
  {
        int num;
        num=2; 
  }

Here num is a local variable so it will be created on stack .

Now consider the below example

public class TestClass
{          
    public int num;
}
public void DoCalulation()
{
    TestClass myTestClass = new TestClass ();
    myTestClass.num=2;
}

This time num is the num is created on heap.Ya in some cases value types perform more than reference types as they don't require garbage collection.

Also remeber:

The value of a value type is always a value of that type. The value of a reference type is always a reference.

And you have to think over the issue that if you expect that there will lot be instantiation then that means more heap space yow will deal with ,and more is the work of garbage collector.For that case you can choose structs.

Answer 6

the difference is that a struct is a value-type I've found them useful in 2 situations

1) Interop - you can specify the memory layout of a struct, so you can guarantee that when you invoke an unmanaged call.

2) Performance - in some (very limited) cases, structs can be faster than classes, In general, this requires structs to be small (I've heard 16 bytes or less) , and not be changed often.

Answer 7

One of the main reasons is that, when used as local variables during a method call, structs are allocated on the stack.

Stack allocation is cheap, but the big difference is that de-allocation is also very cheap. In this situation, the garbage collector doesn't have to track structs -- they're removed when returning from the method that allocated them when the stack frame is popped.

• edit - clarified my post re: Jon Skeet's comment.

Answer 8

Structs have many different semantics to classes. The differences are many but the primary reasons for their existence are:

1. They can be explicitly layed out in memmory
   • this allows certain interop scenarios
2. They may be allocated on the stack
   • Making some sorts of high performance code possible in a much simpler fashion

Answer 9

A struct is a value type (like Int32), whereas a class is a reference type. Structs get created on the stack rather than the heap. Also, when a struct is passed to a method, a copy of the struct is passed, but when a class instance is passed, a reference is passed.

If you need to create your own datatype, say, then a struct is often a better choice than a class as you can use it just like the built-in value types in the .NET framework. There some good struct examples you can read here .