【C#基础】函数传参大总结

目录

• 前言
• 参数是值类型的情况
• • • [1. 按值传递（Pass by Value）](#1. 按值传递（Pass by Value）)
    • [2. 按引用传递（Pass by Reference）](#2. 按引用传递（Pass by Reference）)
    • • [使用 `ref`](#使用 ref)
      • [使用 `in`](#使用 in)
    • [3. 输出参数传递（Output Parameters）](#3. 输出参数传递（Output Parameters）)
    • 参数修饰符对比
    • 小结
• 参数是引用类型的情况
• • • [1. 按值传递类对象](#1. 按值传递类对象)
    • • 虽然类是引用类型，但默认情况下将类对象传递给函数时，传递的仍是`引用的副本`。
    • [2. 按引用传递类对象（`ref`）](#2. 按引用传递类对象（ref）)
    • [3. 使用 `out` 参数](#3. 使用 out 参数)
    • [4. 使用 `in` 参数](#4. 使用 in 参数)
    • 小结
    • • 虽然类是引用类型，但默认情况下将类对象传递给函数时，传递的仍是`引用的副本`。
• 最后一问
• • • 如果传递的是结构体呢？

前言

在C#中，函数传参有三种主要的方式：按值传递 、按引用传递 和输出参数传递。每种方式的使用场景和效果都不同，下面我将详细讲解这三种方式。

参数是值类型的情况

1. 按值传递（Pass by Value）

这是最常见的参数传递方式。默认情况下，C# 函数的参数是按值传递的。这意味着调用函数时，实参的值会被复制到形参，因此对形参的修改不会影响实参。

void ModifyValue(int x)
{
    x = 10;
}

int number = 5;
ModifyValue(number);
Console.WriteLine(number);  // 输出: 5

在这个例子中，number 的值并不会因为函数内部的修改而改变，因为 x 只是 number 的副本。

2. 按引用传递（Pass by Reference）

通过使用 ref 或 in 关键字，可以按引用传递参数。按引用传递时，传递的不是值的副本，而是变量本身的引用。函数可以直接修改原始变量的值。

使用 ref

ref 关键字允许函数修改传递进来的参数的值，并且要求传入的参数必须先初始化。

void ModifyRef(ref int x)
{
    x = 10;
}

int number = 5;
ModifyRef(ref number);
Console.WriteLine(number);  // 输出: 10

在这个例子中，number 的值被函数修改了，因为 ref 让参数传递的是引用。

使用 in

in 关键字表示按引用传递，但参数只能在函数内部读取，不能修改。

void ReadValue(in int x)
{
    Console.WriteLine(x);
    // x = 10; // 编译错误，不能修改 in 参数
}

int number = 5;
ReadValue(in number);

in 参数保证了函数不能修改传递进来的值，只能读取。这对于需要高效传递大型数据结构而不希望其被修改时特别有用。

3. 输出参数传递（Output Parameters）

out 关键字允许函数返回多个值或将数据传递回调用者。与 ref 类似，out 也是按引用传递的，但它不要求变量在传入时已经初始化。函数必须在返回前给 out 参数赋值。

void GetValues(out int x, out int y)
{
    x = 10;
    y = 20;
}

int a, b;
GetValues(out a, out b);
Console.WriteLine(a);  // 输出: 10
Console.WriteLine(b);  // 输出: 20

在这个例子中，a 和 b 的值在函数内部被初始化并返回给调用者。

参数修饰符对比

• 按值传递（默认）：函数对形参的修改不会影响实参。
• ref：传递引用，形参和实参指向同一个变量，函数可以修改原始变量。
• in：按引用传递，但函数只能读取，不可修改。
• out：函数必须对参数赋值，用于返回多个值。

小结

C# 提供了灵活的参数传递方式，开发者可以根据需求选择是按值传递、按引用传递还是使用 out 进行输出。这些方式为开发高效、安全的代码提供了很大的帮助。

参数是引用类型的情况

和C++不同，C#的任何class对象都是引用。

在C#中，如果传递的是类对象 ，情况会有所不同，因为类是引用类型。当你把类对象作为参数传递给函数时，不论是按值传递还是按引用传递，都会对类对象的行为产生影响。让我们仔细看一下如何处理类对象的传递。

1. 按值传递类对象

虽然类是引用类型，但默认情况下将类对象传递给函数时，传递的仍是引用的副本。

这意味着函数内部对对象属性的修改将会影响到原始对象，因为引用指向的是同一个对象。但如果函数试图重新分配整个对象的引用，外部对象则不会受到影响。

class Person
{
    public string Name { get; set; }
}

void ModifyPerson(Person p)
{
    p.Name = "Alice"; // 修改属性
}

Person person = new Person { Name = "Bob" };
ModifyPerson(person);
Console.WriteLine(person.Name);  // 输出: Alice

在上面的例子中，虽然是按值传递，但类对象是引用类型，因此 person 和 p 都引用同一个对象，修改了 p.Name 也会修改 person.Name。

然而，如果在函数内部重新赋值引用，外部的对象将不会改变：

void ReassignPerson(Person p)
{
    p = new Person { Name = "Charlie" };  // 重新分配引用
}

Person person = new Person { Name = "Bob" };
ReassignPerson(person);
Console.WriteLine(person.Name);  // 输出: Bob

在这个例子中，函数内部重新分配了 p 的引用，但这不会影响到外部的 person 对象，因为传递的引用本身是按值传递的副本。

2. 按引用传递类对象（ref）

使用 ref 关键字时，可以将对象的引用本身传递给函数。这意味着函数可以重新分配对象，并让外部变量反映这种变化。

void ReassignPersonRef(ref Person p)
{
    p = new Person { Name = "Charlie" };  // 重新分配引用
}

Person person = new Person { Name = "Bob" };
ReassignPersonRef(ref person);
Console.WriteLine(person.Name);  // 输出: Charlie

在这个例子中，函数通过 ref 传递引用，因此 person 现在指向新的 Person 对象。

3. 使用 out 参数

out 参数的行为与 ref 类似，但要求在函数内部必须对传入的参数赋值。适用于需要从函数返回新的对象或初始化传递进来的对象。

void InitializePerson(out Person p)
{
    p = new Person { Name = "David" };  // 必须初始化
}

Person person;
InitializePerson(out person);
Console.WriteLine(person.Name);  // 输出: David

这里，person 是通过 out 参数传递，函数内部必须为其分配一个新对象。

4. 使用 in 参数

in 参数用于按引用传递对象，但它确保对象的引用在函数内部不能被修改。函数可以读取对象的属性和方法，但不能更改引用本身。对于大型对象，它可以避免复制操作，提高效率。

void ReadPerson(in Person p)
{
    Console.WriteLine(p.Name);  // 读取属性是允许的
    // p = new Person();  // 编译错误，不能修改引用
}

Person person = new Person { Name = "Eva" };
ReadPerson(in person);

小结

虽然类是引用类型，但默认情况下将类对象传递给函数时，传递的仍是引用的副本。

如果能理解这句话，不管是哪种情况，那么思想上就是统一的。

最后一问

如果传递的是结构体呢？

在C#中，**结构体（struct）与类（class）**有一个重要的区别：结构体是值类型，而类是引用类型。因此，如果是结构体，请参考 参数是值类型的情况 ！