Math.DivRem Methode

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: System.Runtime.Extensions.dll

Assembly:: mscorlib.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Berechnet den Quotienten zweier Zahlen und gibt außerdem den Rest als Ausgabeparameter zurück.

Überlädt

DivRem(IntPtr, IntPtr)	Erzeugt den Quotienten und den Rest von zwei Zahlen nativer Größe mit Vorzeichen.
DivRem(Int64, Int64, Int64)	Berechnet den Quotienten zweier 64-Bit-Ganzzahlen mit Vorzeichen und gibt außerdem den Rest als Ausgabeparameter zurück.
DivRem(Int32, Int32, Int32)	Berechnet den Quotienten zweier 32-Bit-Ganzzahlen mit Vorzeichen und gibt außerdem den Rest als Ausgabeparameter zurück.
DivRem(UIntPtr, UIntPtr)	Erzeugt den Quotienten und den Rest von zwei Zahlen nativer Größe ohne Vorzeichen.
DivRem(UInt64, UInt64)	Erzeugt den Quotienten und den Rest von zwei 64-Bit-Zahlen ohne Vorzeichen.
DivRem(UInt32, UInt32)	Erzeugt den Quotienten und den Rest von zwei 32-Bit-Zahlen ohne Vorzeichen.
DivRem(Int64, Int64)	Erzeugt den Quotienten und den Rest von zwei 64-Bit-Zahlen mit Vorzeichen.
DivRem(SByte, SByte)	Erzeugt den Quotienten und den Rest von zwei 8-Bit-Zahlen mit Vorzeichen.
DivRem(Int32, Int32)	Erzeugt den Quotienten und den Rest von zwei 32-Bit-Zahlen mit Vorzeichen.
DivRem(Int16, Int16)	Erzeugt den Quotienten und den Rest von zwei 16-Bit-Zahlen mit Vorzeichen.
DivRem(Byte, Byte)	Erzeugt den Quotienten und den Rest von zwei 8-Bit-Zahlen ohne Vorzeichen.
DivRem(UInt16, UInt16)	Erzeugt den Quotienten und den Rest von zwei 16-Bit-Zahlen ohne Vorzeichen.

DivRem(IntPtr, IntPtr)

Erzeugt den Quotienten und den Rest von zwei Zahlen nativer Größe mit Vorzeichen.

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)

Parameter

left: IntPtr
nativeint

Der Dividend.

right: IntPtr
nativeint

Der Divisor.

Gibt zurück

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

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für

DivRem(Int64, Int64, Int64)

Berechnet den Quotienten zweier 64-Bit-Ganzzahlen mit Vorzeichen und gibt außerdem den Rest als 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

Der Dividend.

b: Int64

Der Divisor.

result: Int64

Enthält den Rest, wenn diese Methode zurückgegeben wird.

Gibt zurück

Int64

Der Quotient der angegebenen Zahlen.

Ausnahmen

DivideByZeroException

b ist 0 (null).

Beispiele

Das folgende Beispiel veranschaulicht die DivRem(Int64, Int64, Int64) Methode.

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

Hinweise

Der Restwert entspricht dem Ergebnis des Restoperators.

Siehe auch

IEEERemainder(Double, Double)

Gilt für

DivRem(Int32, Int32, Int32)

Berechnet den Quotienten zweier 32-Bit-Ganzzahlen mit Vorzeichen und gibt außerdem den Rest als 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

Der Dividend.

b: Int32

Der Divisor.

result: Int32

Enthält den Rest, wenn diese Methode zurückgegeben wird.

Gibt zurück

Int32

Der Quotient der angegebenen Zahlen.

Ausnahmen

DivideByZeroException

b ist 0 (null).

Beispiele

Das folgende Beispiel veranschaulicht die DivRem(Int32, Int32, Int32) Methode.

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

Hinweise

Der Restwert entspricht dem Ergebnis des Restoperators.

Siehe auch

IEEERemainder(Double, Double)

Gilt für

DivRem(UIntPtr, UIntPtr)

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotienten und den Rest von zwei Zahlen nativer Größe ohne Vorzeichen.

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)

Parameter

left: UIntPtr
unativeint

Der Dividend.

right: UIntPtr
unativeint

Der Divisor.

Gibt zurück

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

Der Quotient und der Rest der angegebenen Zahlen.

Attribute: CLSCompliantAttribute

Gilt für

DivRem(UInt64, UInt64)

Wichtig

Diese API ist nicht CLS-kompatibel.

Erzeugt den Quotienten und den Rest von zwei 64-Bit-Zahlen ohne Vorzeichen.

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)

Parameter

left: UInt64

Der Dividend.

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)

Wichtig

Diese API ist nicht CLS-kompatibel.

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

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)

Parameter

left: UInt32

Der Dividend.

right: UInt32

Der Divisor.

Gibt zurück

ValueTuple<UInt32,UInt32>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute: CLSCompliantAttribute

Gilt für

DivRem(Int64, Int64)

Erzeugt den Quotienten und den Rest von zwei 64-Bit-Zahlen mit Vorzeichen.

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)

Parameter

left: Int64

Der Dividend.

right: Int64

Der Divisor.

Gibt zurück

ValueTuple<Int64,Int64>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für

DivRem(SByte, SByte)

Wichtig

Diese API ist nicht CLS-kompatibel.

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

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)

Parameter

left: SByte

Der Dividend.

right: SByte

Der Divisor.

Gibt zurück

ValueTuple<SByte,SByte>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute: CLSCompliantAttribute

Gilt für

DivRem(Int32, Int32)

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

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)

Parameter

left: Int32

Der Dividend.

right: Int32

Der Divisor.

Gibt zurück

ValueTuple<Int32,Int32>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für

DivRem(Int16, Int16)

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

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)

Parameter

left: Int16

Der Dividend.

right: Int16

Der Divisor.

Gibt zurück

ValueTuple<Int16,Int16>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für

DivRem(Byte, Byte)

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

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)

Parameter

left: Byte

Der Dividend.

right: Byte

Der Divisor.

Gibt zurück

ValueTuple<Byte,Byte>

Der Quotient und der Rest der angegebenen Zahlen.

Gilt für

DivRem(UInt16, UInt16)

Wichtig

Diese API ist nicht CLS-kompatibel.

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

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)

Parameter

left: UInt16

Der Dividend.

right: UInt16

Der Divisor.

Gibt zurück

ValueTuple<UInt16,UInt16>

Der Quotient und der Rest der angegebenen Zahlen.

Attribute: CLSCompliantAttribute

Gilt für

Math.DivRem Methode

Definition

Überlädt

DivRem(IntPtr, IntPtr)

Parameter

Gibt zurück

Gilt für

DivRem(Int64, Int64, Int64)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Siehe auch

Gilt für

DivRem(Int32, Int32, Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Siehe auch

Gilt für

DivRem(UIntPtr, UIntPtr)

Parameter

Gibt zurück

Gilt für

DivRem(UInt64, UInt64)

Parameter

Gibt zurück

Gilt für

DivRem(UInt32, UInt32)

Parameter

Gibt zurück

Gilt für

DivRem(Int64, Int64)

Parameter

Gibt zurück

Gilt für

DivRem(SByte, SByte)

Parameter

Gibt zurück

Gilt für

DivRem(Int32, Int32)

Parameter

Gibt zurück

Gilt für

DivRem(Int16, Int16)

Parameter

Gibt zurück

Gilt für

DivRem(Byte, Byte)

Parameter

Gibt zurück

Gilt für

DivRem(UInt16, UInt16)

Parameter

Gibt zurück

Gilt für

Zusätzliche Ressourcen