C#每日面试题-类和结构的区别

C#每日面试题-类和结构的区别

在C#面试中，“类（Class）和结构（Struct）的区别”是必考题，也是初学者容易混淆的核心知识点。很多人只知道“类是引用类型，结构是值类型”，但面试考察的核心是“这种类型差异带来的底层逻辑、语法特性、性能影响和应用场景区别”。今天我们从“基础认知→核心差异→底层原理→实际应用→面试避坑”五个层面，把这个知识点讲透，既保证新手能看懂，又能满足面试的深度要求。

一、先理清：类和结构的基础定义

首先明确两者的本质定位——都是C#中用于封装数据和行为的“数据结构”，但设计初衷和类型归属完全不同：

1. 类（Class）

官方定义：引用类型，用于创建复杂对象，支持继承、多态等面向对象核心特性，是C#中最常用的类型之一。

简单例子（定义和使用）：

// 定义类（引用类型）
public class Person
{
    // 数据成员
    public string Name { get; set; }
    public int Age { get; set; }
    
    // 行为成员
    public void SayHello()
    {
        Console.WriteLine($"我是{Name}，今年{Age}岁");
    }
}

// 使用类
Person person1 = new Person();
person1.Name = "张三";
person1.Age = 25;
person1.SayHello();

2. 结构（Struct）

官方定义：值类型，主要用于封装小型数据结构，设计初衷是“高效存储数据”，不支持继承（除了隐式继承object）。

简单例子（定义和使用）：

// 定义结构（值类型）
public struct Point
{
    // 数据成员
    public int X;
    public int Y;
    
    // 行为成员（可定义方法）
    public double GetDistance()
    {
        return Math.Sqrt(X*X + Y*Y);
    }
}

// 使用结构
Point point1; // 值类型可直接声明，无需new（默认初始化所有字段为0）
point1.X = 3;
point1.Y = 4;
Console.WriteLine(point1.GetDistance()); // 输出5

从基础例子能看出：两者都能封装数据和方法，但使用方式（如结构可直接声明）和设计定位已有差异。下面我们拆解核心区别。

二、核心差异：从5个维度全面对比

类和结构的差异本质是“引用类型”和“值类型”的差异延伸，但还包含语法特性、设计规范等额外区别。用表格先直观对比，再逐个展开讲解：

对比维度	类（Class）	结构（Struct）
类型归属	引用类型	值类型
内存分配	数据存储在堆，栈存储引用地址	数据直接存储在栈（除非作为类成员，存储在堆）
默认构造函数	编译器自动生成无参默认构造函数（可重写）	编译器不生成无参默认构造函数（不可自定义无参构造）
继承特性	支持单继承、多接口实现	不支持继承（除隐式继承object），支持多接口实现
赋值行为	赋值的是引用地址，多个变量指向同一对象	赋值的是数据副本，多个变量相互独立
空值支持	可直接赋值为null（表示无引用）	默认不可为null，需用可空类型（Nullable）
析构函数	可定义析构函数（释放非托管资源）	不可定义析构函数

1. 底层核心：内存分配与访问机制

这是两者最根本的区别，直接决定了性能和使用方式：

• 类（引用类型）：
  当用new Person()创建对象时，会发生两件事：① 在堆上分配一块内存，存储Name、Age等数据；② 在栈上分配一个引用地址，指向堆上的这块内存。后续访问person1的成员时，先通过栈上的引用找到堆上的数据，再进行操作。关键细节：堆上的对象由垃圾回收器（GC）负责回收，频繁创建类对象会增加GC压力。

• 结构（值类型）：
  当声明Point point1时，直接在栈上分配内存，存储X和Y的值。访问point1.X时，直接操作栈上的数据，无需间接跳转。关键细节：栈内存由编译器自动释放（出作用域后立即释放），无需GC参与，访问速度更快。但如果结构作为类的成员（如Person类中定义Point类型的字段），则该结构数据会随类对象一起存储在堆上。

2. 语法特性：构造函数与继承的限制

这是面试中高频考察的细节，很多初学者会在这里踩坑：

（1）构造函数的差异

类：编译器默认生成无参构造函数，我们也可以自定义无参构造或带参构造（自定义无参构造后，编译器不再生成默认无参构造）。

结构：编译器不会生成无参默认构造函数，且我们不能自定义无参构造函数（C#语法规定）。结构的构造函数必须是带参的，且必须初始化所有字段：

// 结构的带参构造函数（必须初始化所有字段）
public struct Point
{
    public int X;
    public int Y;
    
    // 正确：带参构造，初始化所有字段
    public Point(int x, int y)
    {
        X = x;
        Y = y;
    }
    
    // 错误：不能定义无参构造函数
    // public Point() {}
}

另外，结构可以直接声明使用（如Point point1;），此时所有字段会被默认初始化为0（值类型的默认值）；而类必须通过new创建（除非赋值为null），否则无法访问成员。

（2）继承的差异

类：支持单继承（一个类只能继承一个父类），同时支持实现多个接口。比如：

// 类继承父类，同时实现两个接口
public class Student : Person, IStudy, IExam
{
    // ...
}

结构：不支持继承任何类（只能隐式继承object类和ValueType类），但可以实现多个接口。比如：

// 结构实现接口（正确）
public struct Point : IComparable
{
    public int CompareTo(object obj) { ... }
}

// 结构继承类（错误）
// public struct Point : Person { ... }

3. 行为差异：赋值、传参与空值处理

这些差异直接影响代码的正确性，是面试中“代码改错题”的常见考点：

（1）赋值行为

类（引用类型）：赋值的是引用地址，多个变量指向同一个堆对象，修改一个会影响其他：

Person p1 = new Person { Name = "张三", Age = 25 };
Person p2 = p1; // 赋值引用地址，p1和p2指向同一个对象
p2.Age = 30;
Console.WriteLine(p1.Age); // 输出30（p1的Age也被修改）

结构（值类型）：赋值的是数据副本，多个变量相互独立，修改一个不影响其他：

Point p1 = new Point { X = 3, Y = 4 };
Point p2 = p1; // 赋值数据副本，p1和p2是独立的
p2.X = 5;
Console.WriteLine(p1.X); // 输出3（p1的X未被修改）

（2）传参行为

类作为参数传递时，传递的是引用地址，方法内修改参数会影响外部对象；结构作为参数传递时，默认传递副本（修改不影响外部），若要修改外部结构，需用ref或out关键字：

// 类作为参数（传递引用）
public static void ModifyPerson(Person p)
{
    p.Age = 30; // 影响外部对象
}

// 结构作为参数（默认传递副本）
public static void ModifyPoint(Point p)
{
    p.X = 5; // 不影响外部结构
}

// 结构作为参数（用ref传递引用，影响外部）
public static void ModifyPointRef(ref Point p)
{
    p.X = 5; // 影响外部结构
}

（3）空值处理

类：可直接赋值为null，表示“没有指向任何堆对象”：

Person p = null; // 正确
if (p == null) { ... }

结构：默认是值类型，不能直接赋值为null。若需要表示“空状态”，需使用可空类型（Nullable或T?）：

// Point p = null; // 错误：结构不能直接为null
Nullable<Point> p1 = null; // 正确：可空类型
Point? p2 = null; // 简写（推荐）
if (p2.HasValue) { ... } // 判断是否有值
Point p3 = p2.Value; // 获取值（无值时抛异常）

三、实际应用：什么时候用类？什么时候用结构？

面试中除了考察差异，还会问“应用场景”，核心原则是：类适合复杂对象、需要继承多态；结构适合小型数据、追求高效访问。具体建议如下：

1. 优先使用结构（Struct）的场景

• 数据量小：字段少（如2-4个值类型字段），总大小不超过16字节（栈内存访问效率最优）；

• 数据不可变（或变化少）：结构的赋值是副本，频繁修改会产生大量副本，影响性能；

• 不需要继承：仅需封装数据和简单行为（如计算、比较）；

• 高频创建和访问：如坐标点（Point）、颜色（Color）、时间间隔（TimeSpan）等（C#内置的Point、Color、TimeSpan都是结构）。

2. 优先使用类（Class）的场景

• 数据量大或复杂：字段多、包含引用类型成员（如string、数组），此时结构会占用大量栈内存，甚至导致栈溢出；

• 需要继承或多态：如Person类派生出Student、Teacher类，需要用多态实现不同的行为；

• 需要共享数据：多个地方需要操作同一个对象（如全局配置、缓存对象）；

• 需要释放非托管资源：类可定义析构函数或实现IDisposable接口，结构不支持析构函数。

四、面试高频追问：这些坑你必须避开

除了基础差异，面试官还会问一些细节坑题，考察你对知识点的精准掌握：

1. 结构中可以包含引用类型成员吗？

可以，但要注意内存分配：结构本身存储在栈上，但引用类型成员的“引用地址”存储在栈上，实际数据仍存储在堆上。例如：

public struct PersonStruct
{
    public string Name; // 引用类型成员
    public int Age;
}

PersonStruct ps;
ps.Name = "张三"; // Name的引用地址在栈，"张三"数据在堆
ps.Age = 25; // Age直接在栈上

坑点：此时结构的赋值仍会复制引用地址，多个结构实例的Name会指向同一个堆对象，修改一个会影响其他：

PersonStruct ps1 = new PersonStruct { Name = "张三", Age = 25 };
PersonStruct ps2 = ps1;
ps2.Name = "李四";
Console.WriteLine(ps1.Name); // 输出"李四"（引用同一个字符串对象）

2. 结构实现接口时，会触发装箱吗？

会！因为接口是引用类型，将结构赋值给接口变量时，会触发装箱（值类型→引用类型）：

public interface IComparable
{
    int CompareTo(object obj);
}

public struct Point : IComparable
{
    public int X, Y;
    public int CompareTo(object obj) { ... }
}

Point p = new Point { X=3, Y=4 };
IComparable ic = p; // 触发装箱：Point（值类型）→IComparable（引用类型）

优化方案：用泛型约束避免装箱（和之前装箱拆箱的优化逻辑一致）：

public static int Compare<T>(T a, T b) where T : IComparable
{
    return a.CompareTo(b); // 无装箱，直接调用结构的实现
}

3. 类和结构的默认值有什么差异？

类的默认值是null（无引用）；结构的默认值是“所有字段都初始化为对应值类型的默认值”（如int为0，bool为false，引用类型为null）：

// 类的默认值是null
Person p = default(Person);
Console.WriteLine(p == null); // 输出true

// 结构的默认值是字段默认初始化
Point pt = default(Point);
Console.WriteLine(pt.X == 0 && pt.Y == 0); // 输出true

五、总结：面试回答模板（直接套用）

如果面试中被问到“类和结构的区别”，可以按这个逻辑回答，清晰且有深度：

1. 核心差异：类是引用类型，结构是值类型，这决定了两者的内存分配和访问机制不同；

2. 内存层面：类数据存堆、栈存引用，需GC回收；结构数据存栈（类成员除外），无需GC，访问更快；

3. 语法层面：类支持继承、可定义无参构造和析构函数；结构不支持继承、不能自定义无参构造；

4. 行为层面：类赋值/传参是引用，多个变量共享数据；结构是副本，相互独立；类可直接为null，结构需用可空类型；

5. 应用场景：类适合复杂对象、需要继承多态；结构适合小型数据、高频访问场景。

一句话核心：类和结构的区别本质是引用类型与值类型的差异，选择时核心看“数据复杂度”和“是否需要继承多态”。

今天的知识点就到这里，建议结合代码实际测试一下赋值、传参的差异，尤其是结构中引用类型成员的坑，理解会更深刻。如果有其他C#面试相关的问题，欢迎在评论区交流～