c#编程
Completion requirements
控制台编程
输入
输入可以通过与输出相似的方法获取，使用 System.Console 类的 Read() 和 ReadLine() 方法：
using System;
public class ExampleClass
{
public static void Main()
{
Console.WriteLine("Greetings! What is your name?");
Console.Write("My name is: ");
string name = Console.ReadLine();
Console.WriteLine("Nice to meet you, " + name);
Console.ReadKey();
}
}
上面的程序请求用户输入姓名并显示出来。最后的 Console.ReadKey() 会等待用户按下任意键后再退出程序。
输出
下面的示例程序展示了几种输出文本的方法：
using System;
public class HelloWorld
{
public static void Main()
{
Console.WriteLine("Hello World!"); // 依赖于 "using System;"
Console.Write("This is...");
Console.Write(" my first program!\n");
System.Console.WriteLine("Goodbye World!"); // 无需 "using" 语句
}
}
上述代码会输出以下文本：
Hello World!
This is... my first program!
Goodbye World!
这些文本是通过 System.Console 类输出的。顶部的 using 语句允许编译器找到 Console 类，而不需要每次使用时都指定 System 命名空间。
中间的代码使用了 Write() 方法，它不会自动换行。为了换行，我们可以使用换行符（\n）。如果出于某种原因想要显示 \n 字符而不是换行符，则需要添加第二个反斜杠（\\n）。在 C# 中，反斜杠（\）是转义字符，因为它不是普通字符，而是用于表示某些特殊字符（如换行符）。
错误输出
错误输出用于将错误相关的消息定向到控制台。对于初学者来说，这可能显得没有什么意义，因为它与普通的输出（如上所述）效果相同。如果你决定编写一个运行其他应用程序的程序（例如调度器），你可能希望监控该程序的输出——更具体地说，你可能只希望在发生错误时收到通知。如果你编写程序，使得每当发生错误时，程序就写入 Console.Error 流，那么你可以告诉你的调度程序去监控这个流，并反馈所有发送到它的信息。这样，你的程序可能希望将这些错误日志写入文件，而不是直接在控制台中显示。
你可以在学习流（Streams）和 Process 类后再次回顾这个内容。
命令行参数
命令行参数是在控制台程序执行之前传递给程序的值。例如，Windows 命令提示符包含一个复制命令，它需要两个命令行参数。第一个参数是原始文件，第二个参数是新文件的名称或位置。自定义控制台应用程序也可以接受命令行参数。C# 是基于对象的编程语言，.NET Framework 是微软的编程框架，用于创建 Web 应用程序、控制台应用程序和移动应用程序。
using System;
public class Example
{
public static void Main(string[] args)
{
Console.WriteLine("Last Name: " + args[1]);
Console.Read();
}
}
如果将上面的代码编译为名为 username.exe 的程序，则可以通过命令行传递两个参数进行执行，例如 "Bill" 和 "Gates"：
C:\>username.exe Bill Gates
注意，上面 Main() 方法的参数是一个字符串数组。程序假设会传递两个参数。这个假设使得程序不安全。如果在没有传递预期数量的命令行参数的情况下运行该程序，当它试图访问缺失的参数时，将会崩溃。为了使程序更健壮，我们可以检查用户是否输入了所有必需的参数。
using System;
public class Test
{
public static void Main(string[] args)
{
if (args.Length >= 1)
Console.WriteLine(args[0]);
if (args.Length >= 2)
Console.WriteLine(args[1]);
}
}
尝试仅输入第一个名字或根本不输入任何名字来运行程序。args.Length 属性返回参数的总数。如果没有提供参数，它将返回零。
你还可以通过使用引号（""）将多个参数组合在一起。这在你期望多个参数时非常有用，尤其是当参数需要包含空格（例如文件路径、文件名、全名等）时。
尝试仅输入你的名字或完全不输入名字来运行程序。args.Length 属性返回参数的总数。如果没有提供参数，它将返回零。
你还可以通过使用引号（""）将多个单独的参数组合在一起。这在你预期有多个参数时尤其有用，尤其是当需要包含空格（例如文件路径、文件名、全名等）时。
using System;
class Test
{
public static void Main(string[] args)
{
for (int index = 0; index < args.Length; index++)
{
Console.WriteLine((index + 1) + ": " + args[index]);
}
}
}
如果在命令行中运行以下命令：
C:\> Test.exe Separate words "grouped together"
输出将会是：
1: Separate
2: words
3: grouped together
格式化输出
Console.Write() 和 Console.WriteLine() 允许你输出文本字符串，并且还支持通过变量替换输出字符串。
这两个函数通常将字符串作为第一个参数。当添加其他对象作为参数或数组时，函数将扫描字符串并替换占位符。
例如：
{
int i = 10;
Console.WriteLine("i = {0}", i);
}
在这个例子中，{0} 被大括号包围，表示需要替换的参数索引。你还可以在大括号中找到格式说明符，它以冒号 : 和说明符为前缀（例如 {0:G}）。
四舍五入数字示例
这是一个将数字四舍五入为字符串的小示例。它是 C# Math 类的一个扩展。Round 方法的结果需要四舍五入为字符串，因为有效数字可能包含尾随零，如果使用数字格式，这些零会消失。以下是代码及其调用。你可以尝试编写一个更简洁的版本，达到相同的效果，或者纠正其中的错误！
public static class Constants
{
public const string ROUND_FORMAT = "0.##"; // 只保留必要的小数位
}
class Program
{
static void Main()
{
double number = 123.4567;
string rounded = Math.Round(number, 2).ToString(Constants.ROUND_FORMAT);
Console.WriteLine("Rounded number: " + rounded);
}
}
常量类
四舍五入数字示例
这是一个将数字四舍五入为字符串的小示例。它是 C# 的 Math 类的一个扩展。Round 方法的结果需要四舍五入为字符串，因为有效数字可能包含尾随零，如果使用数字格式，尾随零将消失。以下是代码和它的调用。您可以尝试写出一个更简短的版本，以得到相同的结果，或者修正其中的错误！
常量类包含重复的常量，这些常量应该在代码中只出现一次，以避免不小心修改。（如果某个常量被不小心修改，通常会容易被发现，因为它在多个地方使用。）
using System;
namespace ConsoleApplicationCommons
{
class Common
{
/// <summary>德语中的逗号或小数点</summary>
public const char COMMA = ',';
/// <summary>减号或负号常量</summary>
public const char DASH = '-';
/// <summary>科学计数法中的指数符号，或大写字母 E</summary>
public const char EXPONENT = 'E';
/// <summary>句号或小数点</summary>
public const char PERIOD = '.';
/// <summary>在多个地方使用的零字符串常量</summary>
public const String ZERO = "0";
} // class Common
}
翻译说明：
- COMMA 常量表示逗号或小数点，用于德语格式。
- DASH 常量表示负号。
- EXPONENT 常量用于表示科学计数法中的“E”字符。
- PERIOD 常量表示句号或小数点（在其他语言中可能有不同的符号表示小数点）。
- ZERO 常量是零字符串，用于多个地方，避免重复定义。
Math 类是对 <math.h> 库的增强，并包含了四舍五入的计算方法。
using System;
using System.Globalization;
using System.IO;
using System.Text;
namespace ConsoleApplicationCommons
{
/// <summary>
/// 用于特殊数学计算的类。
/// 注意：除了 Java 库外，不应依赖任何其他类！
/// </summary>
public class Maths
{
public static CultureInfo invC = CultureInfo.InvariantCulture;
/// <summary>
/// 超过此值后，语言将从科学计数法切换为双精度浮点数
/// </summary>
private const double E_TO_DOUBLE = 1E-4;
/// <summary>
/// 最大的数字位数，超过此位数 Convert.ToString(…) 会变得不准确。
/// </summary>
private const short MAX_CHARACTERS = 16;
/// <summary>零的字符串</summary>
private static String strZeros = "000000000000000000000000000000000";
/// <summary>
/// 判断一个字符是否可以作为小数点分隔符
/// </summary>
/// <param name="character">需要检查的字符</param>
/// <returns>
/// 如果该字符可以作为小数点分隔符，返回 true，否则返回 false。
/// </returns>
private static bool IsDecimalSeparator(char c)
{
return ((c == Common.COMMA) || (c == Common.PERIOD));
}
/// <summary>
/// 计算小数点后需要补充多少个零
/// </summary>
/// <param name="separator">语言特定的小数点分隔符</param>
/// <param name="d">需要四舍五入的数字</param>
/// <param name="significantsAfter">小数点后有效数字位数</param>
/// <returns>需要补充的零的数量</returns>
private static short CalculateMissingSignificantZeros(char separator,
double d,
short significantsAfter)
{
short after = FindSignificantsAfterDecimal(separator, d);
short zeros = (short)(significantsAfter
- ((after == 0) ? 1 : after));
return (short)((zeros >= 0) ? zeros : 0);
}
/// <summary>
/// 查找数字中小数点的位置，不依赖于语言。
/// </summary>
/// <param name="value">需要查找的小数点的值</param>
/// <returns>小数点的位置</returns>
private static short FindDecimalSeparatorPosition(String value)
{
short separatorAt = (short)value.IndexOf(Common.COMMA);
return (separatorAt > -1)
? separatorAt : (short)value.IndexOf(Common.PERIOD);
}
/// <summary>
/// 计算数字的有效数字位数（不包括符号和小数点）。
/// </summary>
/// <param name="separator">语言特定的小数点分隔符</param>
/// <param name="d">需要计算的值</param>
/// <param name="significantsAfter">小数点后有效数字位数</param>
/// <returns>有效数字的数量</returns>
private static short FindSignificantDigits(char separator,
double d,
short significantsAfter)
{
if (d == 0) return 0;
else
{
String mantissa = FindMantissa(separator,
Convert.ToString(d, invC));
if (d == (long)d)
{
mantissa = mantissa.Substring(0, mantissa.Length - 1);
}
mantissa = RetrieveDigits(mantissa);
// 找到第一个非零数字的位置：
short nonZeroAt = 0;
for (; (nonZeroAt < mantissa.Length)
&& (mantissa[nonZeroAt] == '0'); nonZeroAt++) ;
return (short)mantissa.Substring(nonZeroAt).Length;
}
}
/// <summary>
/// 查找数字的小数部分有效数字位数。
/// </summary>
/// <param name="separator">语言特定的小数点分隔符</param>
/// <param name="d">需要分析的数字</param>
/// <returns>小数部分的有效数字位数</returns>
private static short FindSignificantsAfterDecimal(char separator,
double d)
{
if (d == 0) return 1;
else
{
String value = ConvertToString(d);
short separatorAt = FindDecimalSeparatorPosition(value);
if (separatorAt > -1) value = value.Substring(separatorAt + 1);
short eAt = (short) value.IndexOf(Common.EXPONENT);
if ((separatorAt == -1) && (eAt == -1)) return 0;
else if (eAt > 0) value = value.Substring(0, eAt);
long longValue = Convert.ToInt64(value, invC);
if (longValue == 0) return 0;
else if (Math.Abs(d) < 1)
{
value = Convert.ToString(longValue, invC);
if (value.Length >= 15)
{
return (byte)Convert.ToString(longValue, invC).Length;
}
else return (byte)(value.Length);
}
else
{
if (value.Length >= 15) return (byte)(value.Length - 1);
else return (byte)(value.Length);
}
}
}
/// <summary>
/// 计算小数点后有效数字的数量，已知小数点前后的总有效数字位数。
/// </summary>
/// <param name="significantsBefore">小数点前的有效数字位数</param>
/// <param name="significantDigits">总有效数字的数量</param>
/// <returns>小数点后有效数字的数量</returns>
private static short FindSignificantsAfterDecimal(
short significantsBefore,
short significantDigits)
{
short significantsAfter =
(short)(significantDigits - significantsBefore);
return (short)((significantsAfter > 0) ? significantsAfter : 0);
}
/// <summary>
/// 计算小数点前的有效数字位数。
/// </summary>
/// <param name="separator">语言特定的小数点分隔符</param>
/// <param name="value">需要分析的值</param>
/// <returns>小数点前有效数字的数量</returns>
private static short FindSignificantsBeforeDecimal(char separator,
double d)
{
String value = Convert.ToString(d, invC);
// 如果结果明确，立即返回：浮动点数和科学计数法交界的特殊处理：
if ((d == 0) || (Math.Abs(d) >= E_TO_DOUBLE) && (Math.Abs(d) < 1))
{
return 0;
}
else if ((Math.Abs(d) > 0) && (Math.Abs(d) < E_TO_DOUBLE)) return 1;
else
{
short significants = 0;
for (short s = 0; s < value.Length; s++)
{
if (IsDecimalSeparator(value[s])) break;
else if (value[s] != Common.DASH) significants++;
}
return significants;
}
}
/// <summary>
/// 返回数字的指数部分。
/// </summary>
/// <param name="d">需要提取指数的值</param>
/// <returns>指数部分，或者是零。</returns>
private static short FindExponent(double d)
{
return short.Parse(FindExponent(Convert.ToString(d, invC)), invC);
}
/// <summary>
/// 查找数字的指数部分。
/// </summary>
/// <param name="value">需要查找指数的值</param>
/// <returns>指数部分，如果存在的话，返回指数，否则返回“0”。</returns>
private static String FindExponent(String value)
{
short eAt = (short)(value.IndexOf(Common.EXPONENT));
if (eAt < 0) return Common.ZERO;
else
{
return Convert.ToString
(short.Parse(value.Substring(eAt + 1)), invC);
}
}
/// <summary>
/// 查找数字的尾数。
/// </summary>
/// <param name="separator">语言特定的小数点分隔符</param>
/// <param name="value">需要查找尾数的值</param>
/// <returns>数字的尾数</returns>
private static String FindMantissa(char separator,
String value)
{
short eAt = (short)(value.IndexOf(Common.EXPONENT));
if (eAt > -1) value = value.Substring(0, eAt);
if (FindDecimalSeparatorPosition(value) == -1) value += ".0";
return value;
}
/// <summary>
/// 仅获取数字部分
/// </summary>
/// <param name="d">数字</param>
/// <returns>仅包含数字的部分</returns>
private static String RetrieveDigits(double d)
{
double dValue = d;
short exponent = FindExponent(d);
StringBuilder value = new StringBuilder();
if (exponent == 0)
{
value.Append(dValue);
if (value.Length >= MAX_CHARACTERS)
{
value.Clear();
if (Math.Abs(dValue) < 1) value.Append("0");
// 确定科学计数法形式的指数：
exponent = 0;
while (((long)dValue != dValue) && (dValue < 1E11))
{
dValue *= 10;
exponent++;
}
value.Append((long)dValue);
while ((long)dValue != dValue)
{
dValue -= (long)dValue;
dValue *= 10;
value.Append((long)dValue);
}
}
}
else
{
double multiplier = Math.Pow(10, -exponent);
for (short s = 0; (s <= 16) && (exponent != 0); s++)
{
dValue *= multiplier;
value.Append((long)dValue);
dValue -= (long)dValue;
exponent++;
multiplier = 10;
}
}
if (value.Length >= MAX_CHARACTERS + 2)
value.Length = MAX_CHARACTERS + 2;
return RetrieveDigits(value.ToString());
}
/// <summary>
/// 仅获取数字部分
/// </summary>
/// <param name="number">待处理的值</param>
/// <returns>仅包含数字的部分</returns>
private static String RetrieveDigits(String number)
{
// 如果存在指数部分，则去除该部分：
short eAt = (short)number.IndexOf(Common.EXPONENT);
if (eAt > -1) number = number.Substring(0, eAt);
return number.Replace(Convert.ToString(Common.DASH), "").Replace(
Convert.ToString(Common.COMMA), "").Replace(
Convert.ToString(Common.PERIOD), "");
}
/// <summary>
/// 将十进制分隔符插入到正确的位置
/// </summary>
/// <param name="dValue">数字</param>
/// <param name="value">
/// 字符串变量，分隔符将被插入的位置。
/// </param>
private static void InsertSeparator(double dValue, StringBuilder value)
{
short separatorAt = (short)Convert.ToString((long)dValue).Length;
if (separatorAt < value.Length)
value.Insert(separatorAt, Common.PERIOD);
}
/// <summary>
/// 计算基数的指数幂，而不改变数字的小数位部分。
/// </summary>
/// <param name="basis"></param>
/// <param name="exponent">基数的指数幂</param>
/// <returns></returns>
public static double Power(int basis, short exponent)
{
return Power((short)basis, exponent);
}
/// <summary>
/// 计算基数的指数幂，而不改变数字的小数位部分。
/// </summary>
/// <param name="basis"></param>
/// <param name="exponent"></param>
/// <returns>基数的指数幂</returns>
public static double Power(short basis, short exponent)
{
if (basis == 0) return (exponent != 0) ? 1 : 0;
else
{
if (exponent == 0) return 1;
else
{
// Math 方法的幂会改变小数点后的位数，因此不可用。
long result = 1;
short s = 0;
if (exponent > 0)
{
for (; s < exponent; s++) result *= basis;
}
else if (exponent < 0)
{
for (s = exponent; s < 0; s++) result /= basis;
}
return result;
}
}
}
/// <summary>
/// 将数字四舍五入到指定的小数位数。
/// </summary>
/// <param name="d">待四舍五入的数字</param>
/// <param name="separator">
/// 语言特定的十进制分隔符
/// </param>
/// <param name="significantsAfter">
/// 小数点后的有效位数
/// </param>
/// <returns>四舍五入到指定小数位数的数字</returns>
public static double Round(char separator,
double d,
short significantsAfter)
{
if (d == 0) return 0;
else
{
double constant = Power(10, significantsAfter);
short dsExponent = FindExponent(d);
short exponent = dsExponent;
double value = d * constant * Math.Pow(10, -exponent);
String exponentSign = (exponent < 0)
? Convert.ToString(Common.DASH) : "";
if (exponent != 0)
{
exponent = (short)Math.Abs(exponent);
value = Round(value);
}
else
{
while (FindSignificantsBeforeDecimal(separator, value)
< significantsAfter)
{
constant *= 10;
value *= 10;
}
value = Round(value) / constant;
}
// Power 方法不可用，因为指数计算后的数字可能会超出最大 long 值。
exponent -= (short)(Math.Sign(dsExponent) *
(FindSignificantDigits(separator, value, significantsAfter)
- 1));
if (dsExponent != 0)
{
String strValue = Convert.ToString(value, invC);
short separatorAt = FindDecimalSeparatorPosition(strValue);
if (separatorAt > -1)
{
strValue = strValue.Substring(0, separatorAt);
}
strValue += Common.EXPONENT + exponentSign
+ Convert.ToString(exponent);
value = double.Parse(strValue, invC);
}
return value;
}
}
/// <summary>
/// 根据数学规则四舍五入数字。
/// </summary>
/// <param name="d">待四舍五入的数字</param>
/// <returns>四舍五入后的数字</returns>
public static double Round(double d)
{
return (long)(d + .5);
}
/// <summary>
/// 将 double 值转换为字符串，以便反映 double 格式
///（而不是将其自动转换为科学计数法格式，
/// 像 Convert.ToString(double, invC) 一样）。
/// </summary>
/// <param name="d">待转换的值</param>
/// <returns>与原始值格式相同的字符串</returns>
public static String ConvertToString(double d)
{
double dValue = d;
StringBuilder value = new StringBuilder();
if (Math.Sign(dValue) == -1) value.Append(Common.DASH);
if ((dValue > 1E-5) && (dValue < 1E-4))
{
value.Append("0");
while ((long)dValue == 0)
{
dValue *= 10;
if (dValue >= 1) break;
value.Append(Convert.ToString((long)dValue));
}
}
short exponent = FindExponent(d);
if (exponent != 0)
{
value.Append(RetrieveDigits(dValue));
InsertSeparator(dValue, value);
value.Append(Common.EXPONENT);
value.Append(exponent);
}
else
{
value.Append(RetrieveDigits(dValue));
InsertSeparator(dValue, value);
if (value.Length > MAX_CHARACTERS + 3)
{
value.Length = MAX_CHARACTERS + 3;
}
}
return value.ToString();
}
/// <summary>
/// 四舍五入到指定的有效数字位数。
/// </summary>
/// <param name="d">待四舍五入的数字</param>
/// <param name="significantDigits">
/// 请求的有效数字位数
/// </param>
/// <param name="separator">
/// 语言特定的十进制分隔符
/// </param>
/// <returns>四舍五入后的数字</returns>
public static String RoundToString(char separator,
double d,
short significantDigits)
{
// 小数点前的有效数字位数：
short significantsBefore = FindSignificantsBeforeDecimal(separator, d);
// 小数点后应保留的有效数字位数：
short significantsAfter = FindSignificantsAfterDecimal(
significantsBefore, significantDigits);
// 四舍五入到指定的小数位数：
double rounded = Maths.Round(separator, d, significantsAfter);
String exponent = FindExponent(Convert.ToString(rounded, invC));
String mantissa = FindMantissa(separator, Convert.ToString(rounded, invC));
double dMantissa = double.Parse(mantissa, invC);
StringBuilder result = new StringBuilder(mantissa);
// 计算这个数字的有效数字：
short significants = FindSignificantDigits(separator, dMantissa,
significantsAfter);
// 如果必要，添加尾随零：
if (significants <= significantDigits)
{
if (significantsAfter != 0)
{
result.Append(strZeros.Substring(0,
CalculateMissingSignificantZeros(separator,
dMantissa, significantsAfter)));
}
else
{
//去掉小数点及其后面的数字：
short decimalValue = (short) result.ToString().IndexOf(
Convert.ToString(separator));
if (decimalValue > -1) result.Length = decimalValue;
}
}
else if (significantsBefore > significantDigits)
{
d /= Power(10, (short)(significantsBefore - significantDigits));
d = Round(d);
short digits = (short)(significantDigits + ((d < 0) ? 1 : 0));
String strD = d.ToString().Substring(0, digits);
result.Length = 0;
result.Append(strD + strZeros.Substring(0,
significantsBefore - significantDigits));
}
if (short.Parse(exponent, invC) != 0)
{
result.Append(Common.EXPONENT + exponent);
}
return result.ToString();
}// public static String RoundToString(…)
/// <summary>
/// 将数字四舍五入到固定的小数位数。
/// </summary>
/// <param name="separator">
/// 语言特定的小数点分隔符
/// </param>
/// <param name="significantDigits">
/// 请求的有效数字位数
/// </param>
/// <param name="value">待处理的值</param>
/// <returns></returns>
public static String RoundToString(char separator,
float value,
int significantDigits)
{
return RoundToString(separator, (double)value,
(short)significantDigits);
}
}
}
这段代码是一个四舍五入函数的实现，它将浮点数 value 四舍五入到指定的有效数字位数。它的参数包括一个用于确定小数点分隔符的 separator（例如英文句点 . 或其他），一个表示有效数字位数的 significantDigits，以及待四舍五入的 value。它返回一个字符串，表示经过四舍五入处理后的数字。
using System;
using System.Collections.Generic;
namespace ConsoleApplicationCommons
{
class TestCommon
{
/// <summary>
/// 测试通用功能
/// </summary>
/// <param name="args"></param>
static void Main(string[] args)
{
// 测试四舍五入
List<double> values = new List<double>();
values.Add(0.0);
AddValue(1.4012984643248202e-45, values);
AddValue(1.999999757e-5, values);
AddValue(1.999999757e-4, values);
AddValue(1.999999757e-3, values);
AddValue(0.000640589, values);
AddValue(0.3396899998188019, values);
AddValue(0.34, values);
AddValue(7.07, values);
AddValue(118.188, values);
AddValue(118.2, values);
AddValue(123.405009, values);
AddValue(30.76994323730469, values);
AddValue(130.76994323730469, values);
AddValue(540, values);
AddValue(12345, values);
AddValue(123456, values);
AddValue(540911, values);
AddValue(9.223372036854776e56, values);
const short SIGNIFICANTS = 5;
foreach (double element in values)
{
Console.Out.WriteLine("Maths.Round('" + Common.PERIOD + "', "
+ Convert.ToString(element, Maths.invC) + ", "
+ SIGNIFICANTS + ") = " + Maths.RoundToString
(Common.PERIOD, element, SIGNIFICANTS));
}
Console.In.Read();
}
/// <summary>
/// 向列表中添加一个负值和一个正值
/// </summary>
/// <param name="d">值</param>
/// <param name="values">列表</param>
private static void AddValue(double d, List<double> values)
{
values.Add(-d);
values.Add(d);
}
} // class TestCommon
}
此代码的作用是测试 Maths.RoundToString 函数。它通过对多个数字（包括非常小的和非常大的数字）进行四舍五入测试，验证 RoundToString 函数是否按照预期工作。
最后，代码输出结果的部分，主要展示了通过 Maths.RoundToString 函数四舍五入后的数字结果。例如：
Maths.Round('.', 0, 5) = 0.00000
Maths.Round('.', -1.40129846432482E-45, 5) = -1.4012E-45
Maths.Round('.', 1.40129846432482E-45, 5) = 1.4013E-45
Maths.Round('.', -1.999999757E-05, 5) = -1.9999E-5
Maths.Round('.', 1.999999757E-05, 5) = 2.0000E-5
...
这些输出展示了对于不同的输入值，四舍五入到指定的有效数字后，结果是否符合预期。
如果你有兴趣与 C++ 进行对比，可以使用相同的例子在 C++ 中进行测试。如果你想与 Java 进行比较，也可以参考 Java 中的四舍五入示例。
Last modified: Sunday, 12 January 2025, 2:34 PM