8.3 Variables and parameters(cont')

最新推荐文章于 2021-03-08 07:31:26 发布

masterall

最新推荐文章于 2021-03-08 07:31:26 发布

阅读量735

点赞数

CC 4.0 BY-SA版权

分类专栏： c#/c++ 文章标签： parameters variables output reference object string

本文链接：https://blog.youkuaiyun.com/masterall/article/details/538800

c#/c++ 专栏收录该内容

333 篇文章

订阅专栏

本文主要介绍了C#中不同类型的参数。ref关键字用于引用参数，调用时需特别注意参数值可能改变；out修饰符用于输出参数，初始值不重要；params修饰符用于参数数组，可实现可变长度参数列表，还以Console.WriteLine方法为例说明其应用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

pre: x = 1, y = 2
post: x = 2, y = 1
The ref keyword must be used in both the declaration of the formal parameter
and in uses of it. The use of
ref at the call site calls special attention to the parameter, so that a
developer reading the code will
understand that the value of the argument could change as a result of the
call.
An output parameter is similar to a reference parameter, except that the
initial value of the caller-provided
argument is unimportant. An output parameter is declared with an out
modifier. The example
using System;
class Test
{
static void Divide(int a, int b, out int result, out int remainder) {
result = a / b;
remainder = a % b;
}
static void Main() {
for (int i = 1; i < 10; i++)
for (int j = 1; j < 10; j++) {
int ans, r;
Divide(i, j, out ans, out r);
Console.WriteLine("{0} / {1} = {2}r{3}", i, j, ans, r);
}
}
}
shows a Divide method that includes two output parameters.one for the
result of the division and another
for the remainder.
For value, reference, and output parameters, there is a one-to-one
correspondence between caller-provided
arguments and the parameters used to represent them. A parameter array
enables a many-to-one
relationship: many arguments can be represented by a single parameter
array. In other words, parameter
arrays enable variable length argument lists.
A parameter array is declared with a params modifier. There can be only one
parameter array for a given
method, and it must always be the last parameter specified. The type of a
parameter array is always a single
dimensional array type. A caller can either pass a single argument of this
array type, or any number of
arguments of the element type of this array type. For instance, the example
using System;
class Test
{
static void F(params int[] args) {
Console.WriteLine("# of arguments: {0}", args.Length);
for (int i = 0; i < args.Length; i++)
Console.WriteLine("/targs[{0}] = {1}", i, args[i]);
}
static void Main() {
F();
F(1);
F(1, 2);
F(1, 2, 3);
F(new int[] {1, 2, 3, 4});
}
}
shows a method F that takes a variable number of int arguments, and several
invocations of this method.
The output is:
# of arguments:
0

# of arguments:
1

args[0] =
1

# of arguments:
2

args[0] =
1

args[1] =
2

# of arguments:
3

args[0] =
1

args[1] =
2

args[2] =
3

# of arguments:
4

args[0] =
1

args[1] =
2

args[2] =
3

args[3] =
4

Most of the examples presented in this introduction use the WriteLine
method
of the Console class.
The

argument substitution behavior of this method, as exhibited in the
example
int a = 1, b =
2;

Console.WriteLine("a = {0}, b = {1}", a,
b);

is accomplished using a parameter array. The WriteLine method
provides
several overloaded methods
for

the common cases in which a small number of arguments are passed, and
one
method that uses a
parameter

array.

namespace
System

{

public class
Console

{

public static void WriteLine(string s)
{.}

public static void WriteLine(string s, object a)
{.}
public static void WriteLine(string s, object a, object b)
{.}
.

public static void WriteLine(string s, params object[] args)
{.}
}

}