Math.DivRem 方法

參考

定義

命名空間:: System

組件:: System.Runtime.dll

組件:: netstandard.dll

組件:: System.Runtime.Extensions.dll

組件:: mscorlib.dll

重要

部分資訊涉及發行前產品，在發行之前可能會有大幅修改。 Microsoft 對此處提供的資訊，不做任何明確或隱含的瑕疵擔保。

計算兩個數字的商數，並傳回餘數做為輸出參數。

多載

DivRem(IntPtr, IntPtr)	產生兩個帶正負號原生大小數位的商和餘數。
DivRem(Int64, Int64, Int64)	計算兩個 64 位元帶正負號的整數商數，並傳回餘數做為輸出參數。
DivRem(Int32, Int32, Int32)	計算兩個 32 位元帶正負號的整數商數，並傳回餘數做為輸出參數。
DivRem(UIntPtr, UIntPtr)	產生兩個不帶正負號原生大小數位的商和餘數。
DivRem(UInt64, UInt64)	產生兩個不帶正負號64位數位的商和餘數。
DivRem(UInt32, UInt32)	產生兩個不帶正負號32位數位的商和餘數。
DivRem(Int64, Int64)	產生兩個帶正負號64位數位的商和餘數。
DivRem(SByte, SByte)	產生兩個帶正負號8位數位的商和餘數。
DivRem(Int32, Int32)	產生兩個帶正負號32位數位的商和餘數。
DivRem(Int16, Int16)	產生兩個帶正負號16位數位的商和餘數。
DivRem(Byte, Byte)	產生兩個不帶正負號8位數位的商和餘數。
DivRem(UInt16, UInt16)	產生兩個不帶正負號16位數位的商和餘數。

DivRem(IntPtr, IntPtr)

產生兩個帶正負號原生大小數位的商和餘數。

public:
 static ValueTuple<IntPtr, IntPtr> DivRem(IntPtr left, IntPtr right);

public static (IntPtr,IntPtr) DivRem (IntPtr left, IntPtr right);

static member DivRem : nativeint * nativeint -> ValueTuple<nativeint, nativeint>

Public Shared Function DivRem (left As IntPtr, right As IntPtr) As ValueTuple(Of IntPtr, IntPtr)

參數

left: IntPtr
nativeint

被除數。

right: IntPtr
nativeint

除數。

傳回

ValueTuple<IntPtr,IntPtr> ValueTuple<nativeint,nativeint>

指定數位的商和餘數。

適用於

DivRem(Int64, Int64, Int64)

計算兩個 64 位元帶正負號的整數商數，並傳回餘數做為輸出參數。

public:
 static long DivRem(long a, long b, [Runtime::InteropServices::Out] long % result);

public static long DivRem (long a, long b, out long result);

static member DivRem : int64 * int64 * int64 -> int64

Public Shared Function DivRem (a As Long, b As Long, ByRef result As Long) As Long

參數

a: Int64

被除數。

b: Int64

除數。

result: Int64

當此方法傳回時，會包含餘數。

傳回

Int64

指定之數值的商數。

例外狀況

DivideByZeroException

b 為零。

範例

下列範例會示範 DivRem(Int64, Int64, Int64) 方法。

using System;

public class Example
{
   public static void Main()
   {
      // Define several positive and negative dividends.
      long[] dividends = { Int64.MaxValue, 13952, 0, -14032,
                           Int64.MinValue };
      // Define one positive and one negative divisor.
      long[] divisors = { 2000, -2000 };

      foreach (long divisor in divisors)
      {
         foreach (long dividend in dividends)
         {
            long remainder;
            long quotient = Math.DivRem(dividend, divisor, out remainder);
            Console.WriteLine(@"{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}",
                              dividend, divisor, quotient, remainder);
         }
      }
   }
}
// The example displays the following output:
//    9,223,372,036,854,775,807 \ 2,000 = 4,611,686,018,427,387, remainder 1,807
//    13,952 \ 2,000 = 6, remainder 1,952
//    0 \ 2,000 = 0, remainder 0
//    -14,032 \ 2,000 = -7, remainder -32
//    -9,223,372,036,854,775,808 \ 2,000 = -4,611,686,018,427,387, remainder -1,808
//    9,223,372,036,854,775,807 \ -2,000 = -4,611,686,018,427,387, remainder 1,807
//    13,952 \ -2,000 = -6, remainder 1,952
//    0 \ -2,000 = 0, remainder 0
//    -14,032 \ -2,000 = 7, remainder -32
//    -9,223,372,036,854,775,808 \ -2,000 = 4,611,686,018,427,387, remainder -1,808

Module Example
   Public Sub Main()
      ' Define several positive and negative dividends.
      Dim dividends() As Long = { Int64.MaxValue, 13952, 0, -14032, _
                                     Int64.MinValue }
      ' Define one positive and one negative divisor.
      Dim divisors() As Long = { 2000, -2000 }
      
      For Each divisor As Long In divisors
         For Each dividend As Long In dividends
            Dim remainder As Long 
            Dim quotient As Long = Math.DivRem(dividend, divisor, remainder)
            Console.WriteLine("{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}", _
                              dividend, divisor, quotient, remainder)
         Next
      Next                                
   End Sub
End Module
' The example displays the following output:
'    9,223,372,036,854,775,807 \ 2,000 = 4,611,686,018,427,387, remainder 1,807
'    13,952 \ 2,000 = 6, remainder 1,952
'    0 \ 2,000 = 0, remainder 0
'    -14,032 \ 2,000 = -7, remainder -32
'    -9,223,372,036,854,775,808 \ 2,000 = -4,611,686,018,427,387, remainder -1,808
'    9,223,372,036,854,775,807 \ -2,000 = -4,611,686,018,427,387, remainder 1,807
'    13,952 \ -2,000 = -6, remainder 1,952
'    0 \ -2,000 = 0, remainder 0
'    -14,032 \ -2,000 = 7, remainder -32
'    -9,223,372,036,854,775,808 \ -2,000 = 4,611,686,018,427,387, remainder -1,808

備註

餘數值等於餘數運算子的結果。

另請參閱

IEEERemainder(Double, Double)

適用於

DivRem(Int32, Int32, Int32)

計算兩個 32 位元帶正負號的整數商數，並傳回餘數做為輸出參數。

public:
 static int DivRem(int a, int b, [Runtime::InteropServices::Out] int % result);

public static int DivRem (int a, int b, out int result);

static member DivRem : int * int * int -> int

Public Shared Function DivRem (a As Integer, b As Integer, ByRef result As Integer) As Integer

參數

a: Int32

被除數。

b: Int32

除數。

result: Int32

當此方法傳回時，會包含餘數。

傳回

Int32

指定之數值的商數。

例外狀況

DivideByZeroException

b 為零。

範例

下列範例會示範 DivRem(Int32, Int32, Int32) 方法。

using System;

public class Example
{
   public static void Main()
   {
      // Define several positive and negative dividends.
      int[] dividends = { Int32.MaxValue, 13952, 0, -14032,
                                     Int32.MinValue };
      // Define one positive and one negative divisor.
      int[] divisors = { 2000, -2000 };

      foreach (int divisor in divisors)
      {
         foreach (int dividend in dividends)
         {
            int remainder;
            int quotient = Math.DivRem(dividend, divisor, out remainder);
            Console.WriteLine(@"{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}",
                              dividend, divisor, quotient, remainder);
         }
      }
   }
}
// The example displays the following output:
//       2,147,483,647 \ 2,000 = 1,073,741, remainder 1,647
//       13,952 \ 2,000 = 6, remainder 1,952
//       0 \ 2,000 = 0, remainder 0
//       -14,032 \ 2,000 = -7, remainder -32
//       -2,147,483,648 \ 2,000 = -1,073,741, remainder -1,648
//       2,147,483,647 \ -2,000 = -1,073,741, remainder 1,647
//       13,952 \ -2,000 = -6, remainder 1,952
//       0 \ -2,000 = 0, remainder 0
//       -14,032 \ -2,000 = 7, remainder -32
//       -2,147,483,648 \ -2,000 = 1,073,741, remainder -1,648

Module Example
   Public Sub Main()
      ' Define several positive and negative dividends.
      Dim dividends() As Integer = { Int32.MaxValue, 13952, 0, -14032, _
                                     Int32.MinValue }
      ' Define one positive and one negative divisor.
      Dim divisors() As Integer = { 2000, -2000 }
      
      For Each divisor As Integer In divisors
         For Each dividend As Integer In dividends
            Dim remainder As Integer 
            Dim quotient As Integer = Math.DivRem(dividend, divisor, remainder)
            Console.WriteLine("{0:N0} \ {1:N0} = {2:N0}, remainder {3:N0}", _
                              dividend, divisor, quotient, remainder)
         Next
      Next                                
   End Sub
End Module
' The example displays the following output:
'       2,147,483,647 \ 2,000 = 1,073,741, remainder 1,647
'       13,952 \ 2,000 = 6, remainder 1,952
'       0 \ 2,000 = 0, remainder 0
'       -14,032 \ 2,000 = -7, remainder -32
'       -2,147,483,648 \ 2,000 = -1,073,741, remainder -1,648
'       2,147,483,647 \ -2,000 = -1,073,741, remainder 1,647
'       13,952 \ -2,000 = -6, remainder 1,952
'       0 \ -2,000 = 0, remainder 0
'       -14,032 \ -2,000 = 7, remainder -32
'       -2,147,483,648 \ -2,000 = 1,073,741, remainder -1,648

備註

餘數值等於餘數運算子的結果。

另請參閱

IEEERemainder(Double, Double)

適用於

DivRem(UIntPtr, UIntPtr)

重要

此 API 不符合 CLS 規範。

產生兩個不帶正負號原生大小數位的商和餘數。

public:
 static ValueTuple<UIntPtr, UIntPtr> DivRem(UIntPtr left, UIntPtr right);

[System.CLSCompliant(false)]
public static (UIntPtr,UIntPtr) DivRem (UIntPtr left, UIntPtr right);

public static (UIntPtr,UIntPtr) DivRem (UIntPtr left, UIntPtr right);

[<System.CLSCompliant(false)>]
static member DivRem : unativeint * unativeint -> ValueTuple<unativeint, unativeint>

static member DivRem : unativeint * unativeint -> ValueTuple<unativeint, unativeint>

Public Shared Function DivRem (left As UIntPtr, right As UIntPtr) As ValueTuple(Of UIntPtr, UIntPtr)

參數

left: UIntPtr
unativeint

被除數。

right: UIntPtr
unativeint

除數。

傳回

ValueTuple<UIntPtr,UIntPtr> ValueTuple<unativeint,unativeint>

指定數位的商和餘數。

屬性: CLSCompliantAttribute

適用於

DivRem(UInt64, UInt64)

重要

此 API 不符合 CLS 規範。

產生兩個不帶正負號64位數位的商和餘數。

public:
 static ValueTuple<System::UInt64, System::UInt64> DivRem(System::UInt64 left, System::UInt64 right);

[System.CLSCompliant(false)]
public static (ulong,ulong) DivRem (ulong left, ulong right);

public static (ulong,ulong) DivRem (ulong left, ulong right);

[<System.CLSCompliant(false)>]
static member DivRem : uint64 * uint64 -> ValueTuple<uint64, uint64>

static member DivRem : uint64 * uint64 -> ValueTuple<uint64, uint64>

Public Shared Function DivRem (left As ULong, right As ULong) As ValueTuple(Of ULong, ULong)

參數

left: UInt64

被除數。

right: UInt64

除數。

傳回

ValueTuple<UInt64,UInt64>

指定數位的商和餘數。

屬性: CLSCompliantAttribute

適用於

DivRem(UInt32, UInt32)

重要

此 API 不符合 CLS 規範。

產生兩個不帶正負號32位數位的商和餘數。

public:
 static ValueTuple<System::UInt32, System::UInt32> DivRem(System::UInt32 left, System::UInt32 right);

[System.CLSCompliant(false)]
public static (uint,uint) DivRem (uint left, uint right);

public static (uint,uint) DivRem (uint left, uint right);

[<System.CLSCompliant(false)>]
static member DivRem : uint32 * uint32 -> ValueTuple<uint32, uint32>

static member DivRem : uint32 * uint32 -> ValueTuple<uint32, uint32>

Public Shared Function DivRem (left As UInteger, right As UInteger) As ValueTuple(Of UInteger, UInteger)

參數

left: UInt32

被除數。

right: UInt32

除數。

傳回

ValueTuple<UInt32,UInt32>

指定數位的商和餘數。

屬性: CLSCompliantAttribute

適用於

DivRem(Int64, Int64)

產生兩個帶正負號64位數位的商和餘數。

public:
 static ValueTuple<long, long> DivRem(long left, long right);

public static (long,long) DivRem (long left, long right);

static member DivRem : int64 * int64 -> ValueTuple<int64, int64>

Public Shared Function DivRem (left As Long, right As Long) As ValueTuple(Of Long, Long)

參數

left: Int64

被除數。

right: Int64

除數。

傳回

ValueTuple<Int64,Int64>

指定數位的商和餘數。

適用於

DivRem(SByte, SByte)

重要

此 API 不符合 CLS 規範。

產生兩個帶正負號8位數位的商和餘數。

public:
 static ValueTuple<System::SByte, System::SByte> DivRem(System::SByte left, System::SByte right);

[System.CLSCompliant(false)]
public static (sbyte,sbyte) DivRem (sbyte left, sbyte right);

public static (sbyte,sbyte) DivRem (sbyte left, sbyte right);

[<System.CLSCompliant(false)>]
static member DivRem : sbyte * sbyte -> ValueTuple<sbyte, sbyte>

static member DivRem : sbyte * sbyte -> ValueTuple<sbyte, sbyte>

Public Shared Function DivRem (left As SByte, right As SByte) As ValueTuple(Of SByte, SByte)

參數

left: SByte

被除數。

right: SByte

除數。

傳回

ValueTuple<SByte,SByte>

指定數位的商和餘數。

屬性: CLSCompliantAttribute

適用於

DivRem(Int32, Int32)

產生兩個帶正負號32位數位的商和餘數。

public:
 static ValueTuple<int, int> DivRem(int left, int right);

public static (int,int) DivRem (int left, int right);

static member DivRem : int * int -> ValueTuple<int, int>

Public Shared Function DivRem (left As Integer, right As Integer) As ValueTuple(Of Integer, Integer)

參數

left: Int32

被除數。

right: Int32

除數。

傳回

ValueTuple<Int32,Int32>

指定數位的商和餘數。

適用於

DivRem(Int16, Int16)

產生兩個帶正負號16位數位的商和餘數。

public:
 static ValueTuple<short, short> DivRem(short left, short right);

public static (short,short) DivRem (short left, short right);

static member DivRem : int16 * int16 -> ValueTuple<int16, int16>

Public Shared Function DivRem (left As Short, right As Short) As ValueTuple(Of Short, Short)

參數

left: Int16

被除數。

right: Int16

除數。

傳回

ValueTuple<Int16,Int16>

指定數位的商和餘數。

適用於

DivRem(Byte, Byte)

產生兩個不帶正負號8位數位的商和餘數。

public:
 static ValueTuple<System::Byte, System::Byte> DivRem(System::Byte left, System::Byte right);

public static (byte,byte) DivRem (byte left, byte right);

static member DivRem : byte * byte -> ValueTuple<byte, byte>

Public Shared Function DivRem (left As Byte, right As Byte) As ValueTuple(Of Byte, Byte)

參數

left: Byte

被除數。

right: Byte

除數。

傳回

ValueTuple<Byte,Byte>

指定數位的商和餘數。

適用於

DivRem(UInt16, UInt16)

重要

此 API 不符合 CLS 規範。

產生兩個不帶正負號16位數位的商和餘數。

public:
 static ValueTuple<System::UInt16, System::UInt16> DivRem(System::UInt16 left, System::UInt16 right);

[System.CLSCompliant(false)]
public static (ushort,ushort) DivRem (ushort left, ushort right);

public static (ushort,ushort) DivRem (ushort left, ushort right);

[<System.CLSCompliant(false)>]
static member DivRem : uint16 * uint16 -> ValueTuple<uint16, uint16>

static member DivRem : uint16 * uint16 -> ValueTuple<uint16, uint16>

Public Shared Function DivRem (left As UShort, right As UShort) As ValueTuple(Of UShort, UShort)

參數

left: UInt16

被除數。

right: UInt16

除數。

傳回

ValueTuple<UInt16,UInt16>

指定數位的商和餘數。

屬性: CLSCompliantAttribute

適用於

Math.DivRem 方法

定義

多載

DivRem(IntPtr, IntPtr)

參數

傳回

適用於

DivRem(Int64, Int64, Int64)

參數

傳回

例外狀況

範例

備註

另請參閱

適用於

DivRem(Int32, Int32, Int32)

參數

傳回

例外狀況

範例

備註

另請參閱

適用於

DivRem(UIntPtr, UIntPtr)

參數

傳回

適用於

DivRem(UInt64, UInt64)

參數

傳回

適用於

DivRem(UInt32, UInt32)

參數

傳回

適用於

DivRem(Int64, Int64)

參數

傳回

適用於

DivRem(SByte, SByte)

參數

傳回

適用於

DivRem(Int32, Int32)

參數

傳回

適用於

DivRem(Int16, Int16)

參數

傳回

適用於

DivRem(Byte, Byte)

參數

傳回

適用於

DivRem(UInt16, UInt16)

參數

傳回

適用於

其他資源