Freigeben über

Math.DivRem Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
System.Runtime.Extensions.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Berechnet den Quotienten zweier Zahlen und gibt auch den Rest in einem Ausgabeparameter zurück.

Überlädt

DivRem(Int64, Int64, Int64)

Berechnet den Quotient von zwei 64-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.
DivRem(Int32, Int32, Int32)

Berechnet den Quotient von zwei 32-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.
DivRem(UIntPtr, UIntPtr)

Erzeugt den Quotienten und den Rest von zwei nicht signierten zahlen nativen Größen.
DivRem(UInt64, UInt64)

Erzeugt den Quotienten und den Rest von zwei nicht signierten 64-Bit-Zahlen.
DivRem(UInt32, UInt32)

Erzeugt den Quotient und den Rest von zwei nicht signierten 32-Bit-Zahlen.
DivRem(UInt16, UInt16)

Erzeugt den Quotient und den Rest von zwei nicht signierten 16-Bit-Zahlen.
DivRem(SByte, SByte)

Erzeugt den Quotienten und den Rest von zwei signierten 8-Bit-Zahlen.
DivRem(Int64, Int64)

Erzeugt den Quotient und den Rest von zwei signierten 64-Bit-Zahlen.
DivRem(Int32, Int32)

Erzeugt den Quotienten und den Rest von zwei signierten 32-Bit-Zahlen.
DivRem(Int16, Int16)

Erzeugt den Quotienten und den Rest von zwei signierten 16-Bit-Zahlen.
DivRem(Byte, Byte)

Erzeugt den Quotienten und den Rest von zwei nicht signierten 8-Bit-Zahlen.
DivRem(IntPtr, IntPtr)

Erzeugt den Quotient und den Rest von zwei signierten zahlen nativen Größen.

DivRem(Int64, Int64, Int64)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Berechnet den Quotient von zwei 64-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.

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

Parameter

a
Int64

Die Dividende.

b
Int64

Der Divisor.

result
Int64

Wenn diese Methode zurückgegeben wird, enthält sie den Rest.

Gibt zurück

Int64

Der Quotient der angegebenen Zahlen.

Ausnahmen

DivideByZeroException

b ist Null.

Beispiele

Im folgenden Beispiel wird die DivRem(Int64, Int64, Int64)-Methode veranschaulicht.

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

open System

// Define several positive and negative dividends.
let dividends =
    [ Int64.MaxValue; 13952; 0; -14032; Int64.MinValue ]
// Define one positive and one negative divisor.
let divisors = [ 2000; -2000 ]

for divisor in divisors do
    for dividend in dividends do
        let quotient, remainder = Math.DivRem(dividend, divisor)
        printfn $@"{dividend:N0} \ {divisor:N0} = {quotient:N0}, remainder {remainder:N0}"

// 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

Hinweise

Der Restwert entspricht dem Ergebnis des Restoperators.

Weitere Informationen

Gilt für:

DivRem(Int32, Int32, Int32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Berechnet den Quotient von zwei 32-Bit-ganzzahligen Vorzeichen und gibt auch den Rest in einem Ausgabeparameter zurück.

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

Parameter

a
Int32

Die Dividende.

b
Int32

Der Divisor.

result
Int32

Wenn diese Methode zurückgegeben wird, enthält sie den Rest.

Gibt zurück

Int32

Der Quotient der angegebenen Zahlen.

Ausnahmen

DivideByZeroException

b ist Null.

Beispiele

Im folgenden Beispiel wird die DivRem(Int32, Int32, Int32)-Methode veranschaulicht.

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

open System

// Define several positive and negative dividends.
let dividends = 
    [ Int32.MaxValue; 13952; 0; -14032; Int32.MinValue ]
// Define one positive and one negative divisor.
let divisors = [ 2000; -2000 ]

for divisor in divisors do
    for dividend in dividends do
        let quotient, remainder = Math.DivRem(dividend, divisor)
        printfn $@"{dividend:N0} \ {divisor:N0} = {quotient:N0}, remainder {remainder:N0}"

// 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

Hinweise

Der Restwert entspricht dem Ergebnis des Restoperators.

Weitere Informationen

Gilt für:

DivRem(UIntPtr, UIntPtr)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotienten und den Rest von zwei nicht signierten zahlen nativen Größen.

public:
 static ValueTuple<UIntPtr, UIntPtr> DivRem(UIntPtr left, UIntPtr right);
[System.CLSCompliant(false)]
public static (nuint Quotient, nuint Remainder) DivRem (nuint left, nuint right);
[System.CLSCompliant(false)]
public static (UIntPtr Quotient, UIntPtr Remainder) DivRem (UIntPtr left, UIntPtr right);
[<System.CLSCompliant(false)>]
static member DivRem : unativeint * unativeint -> ValueTuple<unativeint, unativeint>
Public Shared Function DivRem (left As UIntPtr, right As UIntPtr) As ValueTuple(Of UIntPtr, UIntPtr)

Parameter

left
UIntPtr

nuint

unativeint

Die Dividende.

right
UIntPtr

nuint

unativeint

Der Divisor.

Gibt zurück

ValueTuple<UIntPtr,UIntPtr>

ValueTuple<nuint,nuint>

ValueTuple<unativeint,unativeint>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute
CLSCompliantAttribute

Gilt für:

DivRem(UInt64, UInt64)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotienten und den Rest von zwei nicht signierten 64-Bit-Zahlen.

public:
 static ValueTuple<System::UInt64, System::UInt64> DivRem(System::UInt64 left, System::UInt64 right);
[System.CLSCompliant(false)]
public static (ulong Quotient, ulong Remainder) DivRem (ulong left, ulong right);
[<System.CLSCompliant(false)>]
static member DivRem : uint64 * uint64 -> ValueTuple<uint64, uint64>
Public Shared Function DivRem (left As ULong, right As ULong) As ValueTuple(Of ULong, ULong)

Parameter

left
UInt64

Die Dividende.

right
UInt64

Der Divisor.

Gibt zurück

ValueTuple<UInt64,UInt64>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute
CLSCompliantAttribute

Gilt für:

DivRem(UInt32, UInt32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotient und den Rest von zwei nicht signierten 32-Bit-Zahlen.

public:
 static ValueTuple<System::UInt32, System::UInt32> DivRem(System::UInt32 left, System::UInt32 right);
[System.CLSCompliant(false)]
public static (uint Quotient, uint Remainder) DivRem (uint left, uint right);
[<System.CLSCompliant(false)>]
static member DivRem : uint32 * uint32 -> ValueTuple<uint32, uint32>
Public Shared Function DivRem (left As UInteger, right As UInteger) As ValueTuple(Of UInteger, UInteger)

Parameter

left
UInt32

Die Dividende.

right
UInt32

Der Divisor.

Gibt zurück

ValueTuple<UInt32,UInt32>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute
CLSCompliantAttribute

Gilt für:

DivRem(UInt16, UInt16)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotient und den Rest von zwei nicht signierten 16-Bit-Zahlen.

public:
 static ValueTuple<System::UInt16, System::UInt16> DivRem(System::UInt16 left, System::UInt16 right);
[System.CLSCompliant(false)]
public static (ushort Quotient, ushort Remainder) DivRem (ushort left, ushort right);
[<System.CLSCompliant(false)>]
static member DivRem : uint16 * uint16 -> ValueTuple<uint16, uint16>
Public Shared Function DivRem (left As UShort, right As UShort) As ValueTuple(Of UShort, UShort)

Parameter

left
UInt16

Die Dividende.

right
UInt16

Der Divisor.

Gibt zurück

ValueTuple<UInt16,UInt16>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute
CLSCompliantAttribute

Gilt für:

DivRem(SByte, SByte)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotienten und den Rest von zwei signierten 8-Bit-Zahlen.

public:
 static ValueTuple<System::SByte, System::SByte> DivRem(System::SByte left, System::SByte right);
[System.CLSCompliant(false)]
public static (sbyte Quotient, sbyte Remainder) DivRem (sbyte left, sbyte right);
[<System.CLSCompliant(false)>]
static member DivRem : sbyte * sbyte -> ValueTuple<sbyte, sbyte>
Public Shared Function DivRem (left As SByte, right As SByte) As ValueTuple(Of SByte, SByte)

Parameter

left
SByte

Die Dividende.

right
SByte

Der Divisor.

Gibt zurück

ValueTuple<SByte,SByte>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute
CLSCompliantAttribute

Gilt für:

DivRem(Int64, Int64)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Erzeugt den Quotient und den Rest von zwei signierten 64-Bit-Zahlen.

public:
 static ValueTuple<long, long> DivRem(long left, long right);
public static (long Quotient, long Remainder) 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)

Parameter

left
Int64

Die Dividende.

right
Int64

Der Divisor.

Gibt zurück

ValueTuple<Int64,Int64>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für:

DivRem(Int32, Int32)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Erzeugt den Quotienten und den Rest von zwei signierten 32-Bit-Zahlen.

public:
 static ValueTuple<int, int> DivRem(int left, int right);
public static (int Quotient, int Remainder) 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)

Parameter

left
Int32

Die Dividende.

right
Int32

Der Divisor.

Gibt zurück

ValueTuple<Int32,Int32>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für:

DivRem(Int16, Int16)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Erzeugt den Quotienten und den Rest von zwei signierten 16-Bit-Zahlen.

public:
 static ValueTuple<short, short> DivRem(short left, short right);
public static (short Quotient, short Remainder) 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)

Parameter

left
Int16

Die Dividende.

right
Int16

Der Divisor.

Gibt zurück

ValueTuple<Int16,Int16>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für:

DivRem(Byte, Byte)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Erzeugt den Quotienten und den Rest von zwei nicht signierten 8-Bit-Zahlen.

public:
 static ValueTuple<System::Byte, System::Byte> DivRem(System::Byte left, System::Byte right);
public static (byte Quotient, byte Remainder) 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)

Parameter

left
Byte

Die Dividende.

right
Byte

Der Divisor.

Gibt zurück

ValueTuple<Byte,Byte>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für:

DivRem(IntPtr, IntPtr)

Quelle:
Math.cs
Quelle:
Math.cs
Quelle:
Math.cs

Erzeugt den Quotient und den Rest von zwei signierten zahlen nativen Größen.

public:
 static ValueTuple<IntPtr, IntPtr> DivRem(IntPtr left, IntPtr right);
public static (nint Quotient, nint Remainder) DivRem (nint left, nint right);
public static (IntPtr Quotient, IntPtr Remainder) 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)

Parameter

left
IntPtr

nint

nativeint

Die Dividende.

right
IntPtr

nint

nativeint

Der Divisor.

Gibt zurück

ValueTuple<IntPtr,IntPtr>

ValueTuple<nint,nint>

ValueTuple<nativeint,nativeint>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für: