Int32 Struktura

Definice

Představuje 32bitové celé číslo s signedm.

public value class int : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
public value class int : IComparable, IComparable<int>, IConvertible, IEquatable<int>, ISpanFormattable
public value class int : IComparable<int>, IConvertible, IEquatable<int>, IParsable<int>, ISpanParsable<int>, System::Numerics::IAdditionOperators<int, int, int>, System::Numerics::IAdditiveIdentity<int, int>, System::Numerics::IBinaryInteger<int>, System::Numerics::IBinaryNumber<int>, System::Numerics::IBitwiseOperators<int, int, int>, System::Numerics::IComparisonOperators<int, int>, System::Numerics::IDecrementOperators<int>, System::Numerics::IDivisionOperators<int, int, int>, System::Numerics::IEqualityOperators<int, int>, System::Numerics::IIncrementOperators<int>, System::Numerics::IMinMaxValue<int>, System::Numerics::IModulusOperators<int, int, int>, System::Numerics::IMultiplicativeIdentity<int, int>, System::Numerics::IMultiplyOperators<int, int, int>, System::Numerics::INumber<int>, System::Numerics::INumberBase<int>, System::Numerics::IShiftOperators<int, int>, System::Numerics::ISignedNumber<int>, System::Numerics::ISubtractionOperators<int, int, int>, System::Numerics::IUnaryNegationOperators<int, int>, System::Numerics::IUnaryPlusOperators<int, int>
public value class int : IComparable, IConvertible, IFormattable
public value class int : IComparable, IComparable<int>, IEquatable<int>, IFormattable
public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, ISpanFormattable
public readonly struct Int32 : IComparable<int>, IConvertible, IEquatable<int>, IParsable<int>, ISpanParsable<int>, System.Numerics.IAdditionOperators<int,int,int>, System.Numerics.IAdditiveIdentity<int,int>, System.Numerics.IBinaryInteger<int>, System.Numerics.IBinaryNumber<int>, System.Numerics.IBitwiseOperators<int,int,int>, System.Numerics.IComparisonOperators<int,int>, System.Numerics.IDecrementOperators<int>, System.Numerics.IDivisionOperators<int,int,int>, System.Numerics.IEqualityOperators<int,int>, System.Numerics.IIncrementOperators<int>, System.Numerics.IMinMaxValue<int>, System.Numerics.IModulusOperators<int,int,int>, System.Numerics.IMultiplicativeIdentity<int,int>, System.Numerics.IMultiplyOperators<int,int,int>, System.Numerics.INumber<int>, System.Numerics.INumberBase<int>, System.Numerics.IShiftOperators<int,int>, System.Numerics.ISignedNumber<int>, System.Numerics.ISubtractionOperators<int,int,int>, System.Numerics.IUnaryNegationOperators<int,int>, System.Numerics.IUnaryPlusOperators<int,int>
[System.Serializable]
public struct Int32 : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable
public struct Int32 : IComparable, IComparable<int>, IEquatable<int>, IFormattable
type int = struct
    interface IConvertible
    interface IFormattable
type int = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable
type int = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<int>
    interface ISpanFormattable
    interface ISpanParsable<int>
    interface IAdditionOperators<int, int, int>
    interface IAdditiveIdentity<int, int>
    interface IBinaryInteger<int>
    interface IBinaryNumber<int>
    interface IBitwiseOperators<int, int, int>
    interface IComparisonOperators<int, int>
    interface IEqualityOperators<int, int>
    interface IDecrementOperators<int>
    interface IDivisionOperators<int, int, int>
    interface IIncrementOperators<int>
    interface IModulusOperators<int, int, int>
    interface IMultiplicativeIdentity<int, int>
    interface IMultiplyOperators<int, int, int>
    interface INumber<int>
    interface INumberBase<int>
    interface ISubtractionOperators<int, int, int>
    interface IUnaryNegationOperators<int, int>
    interface IUnaryPlusOperators<int, int>
    interface IShiftOperators<int, int>
    interface IMinMaxValue<int>
    interface ISignedNumber<int>
[<System.Serializable>]
type int = struct
    interface IFormattable
    interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type int = struct
    interface IFormattable
    interface IConvertible
type int = struct
    interface IFormattable
Public Structure Int32
Implements IComparable, IComparable(Of Integer), IConvertible, IEquatable(Of Integer), IFormattable
Public Structure Int32
Implements IComparable, IComparable(Of Integer), IConvertible, IEquatable(Of Integer), ISpanFormattable
Public Structure Int32
Implements IAdditionOperators(Of Integer, Integer, Integer), IAdditiveIdentity(Of Integer, Integer), IBinaryInteger(Of Integer), IBinaryNumber(Of Integer), IBitwiseOperators(Of Integer, Integer, Integer), IComparable(Of Integer), IComparisonOperators(Of Integer, Integer), IConvertible, IDecrementOperators(Of Integer), IDivisionOperators(Of Integer, Integer, Integer), IEqualityOperators(Of Integer, Integer), IEquatable(Of Integer), IIncrementOperators(Of Integer), IMinMaxValue(Of Integer), IModulusOperators(Of Integer, Integer, Integer), IMultiplicativeIdentity(Of Integer, Integer), IMultiplyOperators(Of Integer, Integer, Integer), INumber(Of Integer), INumberBase(Of Integer), IParsable(Of Integer), IShiftOperators(Of Integer, Integer), ISignedNumber(Of Integer), ISpanParsable(Of Integer), ISubtractionOperators(Of Integer, Integer, Integer), IUnaryNegationOperators(Of Integer, Integer), IUnaryPlusOperators(Of Integer, Integer)
Public Structure Int32
Implements IComparable, IConvertible, IFormattable
Public Structure Int32
Implements IComparable, IComparable(Of Integer), IEquatable(Of Integer), IFormattable
Dědičnost
Atributy
Implementuje
IComparable IComparable<Int32> IConvertible IEquatable<Int32> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> IEquatable<TSelf> IParsable<Int32> IParsable<TSelf> ISpanParsable<Int32> ISpanParsable<TSelf> IAdditionOperators<Int32,Int32,Int32> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Int32,Int32> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Int32> IBinaryNumber<Int32> IBinaryNumber<TSelf> IBitwiseOperators<Int32,Int32,Int32> IBitwiseOperators<TSelf,TSelf,TSelf> System.Numerics.IComparisonOperators<Int32,Int32> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<Int32> IDecrementOperators<TSelf> IDivisionOperators<Int32,Int32,Int32> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<Int32,Int32> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> IIncrementOperators<Int32> IIncrementOperators<TSelf> IMinMaxValue<Int32> IModulusOperators<Int32,Int32,Int32> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Int32,Int32> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Int32,Int32,Int32> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Int32> INumber<TSelf> INumberBase<Int32> INumberBase<TSelf> System.Numerics.IShiftOperators<Int32,Int32> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<Int32> ISubtractionOperators<Int32,Int32,Int32> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Int32,Int32> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Int32,Int32> IUnaryPlusOperators<TSelf,TSelf>

Poznámky

Int32 je neměnný typ hodnoty, který představuje celá čísla se čísly, které jsou v rozsahu od záporných 2 147 483 648 (která je reprezentována konstantou Int32.MinValue ) prostřednictvím kladných 2 147 483 647 (což je reprezentováno konstantou Int32.MaxValue ). .NET obsahuje také celočíselnou hodnotu bez znaménka, která představuje hodnoty v UInt32rozsahu od 0 do 4 294 967 295.

Vytvoření instance hodnoty Int32

Hodnotu můžete vytvořit Int32 několika způsoby:

  • Můžete deklarovat proměnnou Int32 a přiřadit ji celočíselnou hodnotu literálu, která je v rozsahu datového Int32 typu. Následující příklad deklaruje dvě Int32 proměnné a tímto způsobem je přiřadí hodnotám.

    int number1 = 64301;
    int number2 = 25548612;
    
    let number1 = 64301
    let number2 = 25548612
    
    Dim number1 As Integer = 64301
    Dim number2 As Integer = 25548612
    
  • Můžete přiřadit hodnotu celočíselného typu, jehož rozsah je podmnožinou Int32 typu. Jedná se o rozšiřující převod, který nevyžaduje operátor přetypování v jazyce C# nebo metodu převodu v jazyce Visual Basic, ale vyžaduje ho v jazyce F#.

    sbyte value1 = 124;
    short value2 = 1618;
    
    int number1 = value1;
    int number2 = value2;
    
    let value1 = 124y
    let value2 = 1618s
    
    let number1 = int value1
    let number2 = int value2
    
    Dim value1 As SByte = 124
    Dim value2 As Int16 = 1618
    
    Dim number1 As Integer = value1
    Dim number2 As Integer = value2
    
  • Můžete přiřadit hodnotu číselného typu, jejíž rozsah přesahuje Int32 rozsah daného typu. Jedná se o zužující převod, takže vyžaduje operátor přetypování v jazyce C# nebo F# a metodu převodu v jazyce Visual Basic, pokud Option Strict je zapnutá. Pokud je Singlečíselná hodnota , Doublenebo Decimal hodnota, která obsahuje zlomkovou komponentu, zpracování jeho zlomkové části závisí na kompilátoru provádějícím převod. Následující příklad provádí zúžení převodů, aby proměnné přiřadily několik číselných hodnot Int32 .

    long lNumber = 163245617;
    try {
       int number1 = (int) lNumber;
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", lNumber);
    }
    
    double dbl2 = 35901.997;
    try {
       int number2 = (int) dbl2;
       Console.WriteLine(number2);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", dbl2);
    }
    
    BigInteger bigNumber = 132451;
    try {
       int number3 = (int) bigNumber;
       Console.WriteLine(number3);
    }
    catch (OverflowException) {
       Console.WriteLine("{0} is out of range of an Int32.", bigNumber);
    }
    // The example displays the following output:
    //       163245617
    //       35902
    //       132451
    
    let lNumber = 163245617L
    try
        let number1 = int lNumber
        printfn $"{number1}"
    with :? OverflowException ->
        printfn "{lNumber} is out of range of an Int32."
    
    let dbl2 = 35901.997
    try
        let number2 = int dbl2
        printfn $"{number2}"
    with :? OverflowException ->
        printfn $"{dbl2} is out of range of an Int32."
    
    let bigNumber = BigInteger 132451
    try
        let number3 = int bigNumber
        printfn $"{number3}"
    with :? OverflowException ->
        printfn $"{bigNumber} is out of range of an Int32."
    
    // The example displays the following output:
    //       163245617
    //       35902
    //       132451
    
    Dim lNumber As Long = 163245617
    Try
       Dim number1 As Integer = CInt(lNumber)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", lNumber)
    End Try
    
    Dim dbl2 As Double = 35901.997
    Try
       Dim number2 As Integer = CInt(dbl2)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", dbl2)
    End Try
       
    Dim bigNumber As BigInteger = 132451
    Try
       Dim number3 As Integer = CInt(bigNumber)
       Console.WriteLine(number3)
    Catch e As OverflowException
       Console.WriteLine("{0} is out of range of an Int32.", bigNumber)
    End Try    
    ' The example displays the following output:
    '       163245617
    '       35902
    '       132451
    
  • Můžete volat metodu Convert třídy pro převod libovolného podporovaného typu na Int32 hodnotu. To je možné, protože Int32 podporuje IConvertible rozhraní. Následující příklad ukazuje převod pole Decimal hodnot na Int32 hodnoty.

    decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                        199.55m, 9214.16m, Decimal.MaxValue };
    int result;
    
    foreach (decimal value in values)
    {
       try {
          result = Convert.ToInt32(value);
          Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                            value.GetType().Name, value,
                            result.GetType().Name, result);
       }
       catch (OverflowException) {
          Console.WriteLine("{0} is outside the range of the Int32 type.",
                            value);
       }
    }
    // The example displays the following output:
    //    -79228162514264337593543950335 is outside the range of the Int32 type.
    //    Converted the Decimal value '-1034.23' to the Int32 value -1034.
    //    Converted the Decimal value '-12' to the Int32 value -12.
    //    Converted the Decimal value '0' to the Int32 value 0.
    //    Converted the Decimal value '147' to the Int32 value 147.
    //    Converted the Decimal value '199.55' to the Int32 value 200.
    //    Converted the Decimal value '9214.16' to the Int32 value 9214.
    //    79228162514264337593543950335 is outside the range of the Int32 type.
    
    let values = 
        [| Decimal.MinValue; -1034.23M; -12m; 0M; 147M
           199.55M; 9214.16M; Decimal.MaxValue |]
    
    for value in values do
        try
            let result = Convert.ToInt32 value
            printfn $"Converted the {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}."
            
        with :? OverflowException ->
            printfn $"{value} is outside the range of the Int32 type."
       
    // The example displays the following output:
    //    -79228162514264337593543950335 is outside the range of the Int32 type.
    //    Converted the Decimal value '-1034.23' to the Int32 value -1034.
    //    Converted the Decimal value '-12' to the Int32 value -12.
    //    Converted the Decimal value '0' to the Int32 value 0.
    //    Converted the Decimal value '147' to the Int32 value 147.
    //    Converted the Decimal value '199.55' to the Int32 value 200.
    //    Converted the Decimal value '9214.16' to the Int32 value 9214.
    //    79228162514264337593543950335 is outside the range of the Int32 type.
    
    Dim values() As Decimal = { Decimal.MinValue, -1034.23d, -12d, 0d, 147d, _
                                199.55d, 9214.16d, Decimal.MaxValue }
    Dim result As Integer
    
    For Each value As Decimal In values
       Try
          result = Convert.ToInt32(value)
          Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                            value.GetType().Name, value, _
                            result.GetType().Name, result)
       Catch e As OverflowException
          Console.WriteLine("{0} is outside the range of the Int32 type.", _
                            value)
       End Try   
    Next                                  
    ' The example displays the following output:
    '    -79228162514264337593543950335 is outside the range of the Int32 type.
    '    Converted the Decimal value '-1034.23' to the Int32 value -1034.
    '    Converted the Decimal value '-12' to the Int32 value -12.
    '    Converted the Decimal value '0' to the Int32 value 0.
    '    Converted the Decimal value '147' to the Int32 value 147.
    '    Converted the Decimal value '199.55' to the Int32 value 200.
    '    Converted the Decimal value '9214.16' to the Int32 value 9214.
    '    79228162514264337593543950335 is outside the range of the Int32 type.
    
  • Voláním nebo TryParse metodou Parse lze převést řetězcovou reprezentaci Int32 hodnoty na Int32hodnotu . Řetězec může obsahovat desetinné nebo šestnáctkové číslice. Následující příklad znázorňuje operaci parsování pomocí desítkového i šestnáctkového řetězce.

    string string1 = "244681";
    try {
       int number1 = Int32.Parse(string1);
       Console.WriteLine(number1);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string1);
    }
    
    string string2 = "F9A3C";
    try {
       int number2 = Int32.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber);
       Console.WriteLine(number2);
    }
    catch (OverflowException) {
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2);
    }
    catch (FormatException) {
       Console.WriteLine("The format of '{0}' is invalid.", string2);
    }
    // The example displays the following output:
    //       244681
    //       1022524
    
    let string1 = "244681"
    try
        let number1 = Int32.Parse string1
        printfn $"{number1}"
    with
    | :? OverflowException ->
        printfn "'{string1}' is out of range of a 32-bit integer."
    | :? FormatException ->
        printfn $"The format of '{string1}' is invalid."
    
    let string2 = "F9A3C"
    try
        let number2 = Int32.Parse(string2, System.Globalization.NumberStyles.HexNumber)
        printfn $"{number2}"
    with 
    | :? OverflowException ->
        printfn $"'{string2}' is out of range of a 32-bit integer."
    | :? FormatException ->
        printfn $"The format of '{string2}' is invalid."
    
    // The example displays the following output:
    //       244681
    //       1022524
    
    Dim string1 As String = "244681"
    Try
       Dim number1 As Integer = Int32.Parse(string1)
       Console.WriteLine(number1)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string1)
    End Try
    
    Dim string2 As String = "F9A3C"
    Try
       Dim number2 As Integer = Int32.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber)
       Console.WriteLine(number2)
    Catch e As OverflowException
       Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2)
    Catch e As FormatException
       Console.WriteLine("The format of '{0}' is invalid.", string2)
    End Try
    ' The example displays the following output:
    '       244681
    '       1022524
    

Provádění operací na hodnotách Int32

Typ Int32 podporuje standardní matematické operace, jako je sčítání, odčítání, dělení, násobení, negace a unární negace. Podobně jako ostatní celočíselné typy Int32 podporuje typ také bitové ANDoperátory , , OR, XORlevý posun a operátory posunu doprava.

Standardní číselné operátory můžete použít k porovnání dvou Int32 hodnot nebo můžete volat metodu nebo Equals metoduCompareTo.

Členy třídy můžete také volat Math , aby provedli širokou škálu číselných operací, včetně získání absolutní hodnoty čísla, výpočtu podílu a zbytku z integrálního dělení, určení maximální nebo minimální hodnoty dvou celých čísel, získání znaménka čísla a zaokrouhlení čísla.

Znázornění Int32 jako řetězce

Tento Int32 typ poskytuje úplnou podporu standardních a vlastních řetězců číselného formátu. (Další informace najdete v tématu Typy formátování, standardní řetězce číselného formátu a vlastní řetězce číselného formátu.)

Pokud chcete naformátovat Int32 hodnotu jako celočíselný řetězec bez úvodních nul, můžete volat metodu bez ToString() parametrů. Pomocí specifikátoru formátu "D" můžete do řetězcové reprezentace zahrnout také zadaný počet úvodních nul. Pomocí specifikátoru formátu "N" můžete zahrnout oddělovače skupin a určit počet desetinných číslic, které se mají zobrazit v řetězcové reprezentaci čísla. Pomocí specifikátoru formátu "X" můžete znázorňovat Int32 hodnotu jako šestnáctkový řetězec. Následující příklad formátuje prvky v poli Int32 hodnot těmito čtyřmi způsoby.

int[] numbers = { -1403, 0, 169, 1483104 };
foreach (int number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write("{0,11:D3}", number);
   // Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number);
   // Display value as hexadecimal.
   Console.Write("{0,12:X2}", number);
   // Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number);
}
// The example displays the following output:
//    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
//    0         -->           000          0.0          00      00000000
//    169       -->           169        169.0          A9      000000A9
//    1483104   -->       1483104  1,483,104.0      16A160      0016A160
let numbers = [| -1403; 0; 169; 1483104 |]
for number in numbers do
    // Display value using default formatting.
    printf $"{number,-8}  -->   "
    // Display value with 3 digits and leading zeros.
    printf $"{number,11:D3}"
    // Display value with 1 decimal digit.
    printf $"{number,13:N1}"
    // Display value as hexadecimal.
    printf $"{number,12:X2}"
    // Display value with eight hexadecimal digits.
    printfn $"{number,14:X8}"


  // The example displays the following output:
  //    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
  //    0         -->           000          0.0          00      00000000
  //    169       -->           169        169.0          A9      000000A9
  //    1483104   -->       1483104  1,483,104.0      16A160      0016A160
Dim numbers() As Integer = { -1403, 0, 169, 1483104 }
For Each number As Integer In numbers
   ' Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write("{0,11:D3}", number) 
   ' Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number) 
   ' Display value as hexadecimal.
   Console.Write("{0,12:X2}", number) 
   ' Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number)
Next   
' The example displays the following output:
'    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
'    0         -->           000          0.0          00      00000000
'    169       -->           169        169.0          A9      000000A9
'    1483104   -->       1483104  1,483,104.0      16A160      0016A160

Hodnotu můžete také naformátovat Int32 jako binární, osmičkový, desetinný nebo šestnáctkový řetězec zavoláním ToString(Int32, Int32) metody a zadáním základu jako druhého parametru metody. Následující příklad volá tuto metodu k zobrazení binární, osmičkové a šestnáctkové reprezentace pole celočíselné hodnoty.

int[] numbers = { -146, 11043, 2781913 };
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}",
                  "Value", "Binary", "Octal", "Hex");
foreach (int number in numbers) {
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}",
                     number, Convert.ToString(number, 2),
                     Convert.ToString(number, 8),
                     Convert.ToString(number, 16));
}
// The example displays the following output:
//       Value                             Binary         Octal          Hex
//        -146   11111111111111111111111101101110   37777777556     ffffff6e
//       11043                     10101100100011         25443         2b23
//     2781913             1010100111001011011001      12471331       2a72d9
let numbers = [| -146; 11043; 2781913 |]
printfn $"""{"Value",8}   {"Binary",32}   {"Octal",11}   {"Hex",10}""" 
for number in numbers do
    printfn $"{number,8}   {Convert.ToString(number, 2),32}   {Convert.ToString(number, 8),11}   {Convert.ToString(number, 16),10}"

// The example displays the following output:
//       Value                             Binary         Octal          Hex
//        -146   11111111111111111111111101101110   37777777556     ffffff6e
//       11043                     10101100100011         25443         2b23
//     2781913             1010100111001011011001      12471331       2a72d9
Dim numbers() As Integer = { -146, 11043, 2781913 }
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                  "Value", "Binary", "Octal", "Hex")
For Each number As Integer In numbers
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                     number, Convert.ToString(number, 2), _
                     Convert.ToString(number, 8), _
                     Convert.ToString(number, 16))
Next      
' The example displays the following output:
'       Value                             Binary         Octal          Hex
'        -146   11111111111111111111111101101110   37777777556     ffffff6e
'       11043                     10101100100011         25443         2b23
'     2781913             1010100111001011011001      12471331       2a72d9

Práce se 32bitovými celými čísly bez desetinných hodnot

Kromě práce s jednotlivými celými čísly jako desetinnými hodnotami můžete chtít provádět bitové operace s celočíselnou hodnotou nebo pracovat s binárními nebo šestnáctkovými reprezentacemi celočíselových hodnot. Int32 hodnoty jsou reprezentovány 31 bity, přičemž třicetisekundový bit se používá jako znaménko bit. Kladné hodnoty jsou reprezentovány pomocí reprezentace znaménka a velikosti. Záporné hodnoty jsou v reprezentaci dvou doplňků. Je důležité mít na paměti, když provádíte bitové operace s Int32 hodnotami nebo při práci s jednotlivými bity. Aby bylo možné provést číselnou, logickou nebo porovnávací operaci u všech dvou ne desetinných hodnot, musí obě hodnoty používat stejnou reprezentaci.

Pole

MaxValue

Představuje největší možnou Int32hodnotu . Toto pole je konstantní.

MinValue

Představuje nejmenší možnou Int32hodnotu . Toto pole je konstantní.

Metody

Abs(Int32)

Vypočítá absolutní hodnotu.

Clamp(Int32, Int32, Int32)

Upne hodnotu na minimální a maximální hodnotu včetně.

CompareTo(Int32)

Porovná tuto instanci se zadaným 32bitovým celé číslo se znaménkem a vrátí indikaci jejich relativních hodnot.

CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

CopySign(Int32, Int32)

Zkopíruje znaménko hodnoty na znaménko jiné hodnoty.

CreateChecked<TOther>(TOther)

Vytvoří instanci aktuálního typu z hodnoty a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.

CreateSaturating<TOther>(TOther)

Vytvoří instanci aktuálního typu z hodnoty, která sytá všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.

CreateTruncating<TOther>(TOther)

Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.

DivRem(Int32, Int32)

Vypočítá podíl a zbytek dvou hodnot.

Equals(Int32)

Vrátí hodnotu označující, zda je tato instance rovna zadané Int32 hodnotě.

Equals(Object)

Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.

GetHashCode()

Vrátí hodnotu hash pro tuto instanci.

GetTypeCode()

TypeCode Vrátí hodnotu pro typ Int32hodnoty .

IsEvenInteger(Int32)

Určuje, jestli hodnota představuje sudé číslo.

IsNegative(Int32)

Určuje, jestli je hodnota záporná.

IsOddInteger(Int32)

Určuje, jestli hodnota představuje liché celočíselné číslo.

IsPositive(Int32)

Určuje, jestli je hodnota kladná.

IsPow2(Int32)

Určuje, jestli je hodnota mocninou dvou.

LeadingZeroCount(Int32)

Vypočítá počet počátečních nul v hodnotě.

Log2(Int32)

Vypočítá protokol 2 hodnoty.

Max(Int32, Int32)

Porovná dvě hodnoty s výpočetními prostředky, které jsou větší.

MaxMagnitude(Int32, Int32)

Porovná dvě hodnoty s výpočetními prostředky, které jsou větší.

Min(Int32, Int32)

Porovná dvě hodnoty k výpočtu, což je menší.

MinMagnitude(Int32, Int32)

Porovná dvě hodnoty k výpočtu, což je menší.

Parse(ReadOnlySpan<Char>, IFormatProvider)

Parsuje rozsah znaků do hodnoty.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent.

Parse(String)

Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem.

Parse(String, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselné ekvivalent.

Parse(String, NumberStyles)

Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 32bitový celočíselnou ekvivalent.

Parse(String, NumberStyles, IFormatProvider)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent.

PopCount(Int32)

Vypočítá počet bitů, které jsou nastavené v hodnotě.

RotateLeft(Int32, Int32)

Otočí hodnotu levou o danou částku.

RotateRight(Int32, Int32)

Otočí hodnotu doprava o danou částku.

Sign(Int32)

Vypočítá znaménko hodnoty.

ToString()

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.

ToString(IFormatProvider)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.

ToString(String)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.

ToString(String, IFormatProvider)

Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.

TrailingZeroCount(Int32)

Vypočítá počet koncových nul v hodnotě.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Pokusí se naformátovat hodnotu aktuální celočíselné instance do zadaného rozsahu znaků.

TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)

Pokusí se analyzovat rozsah znaků do hodnoty.

TryParse(ReadOnlySpan<Char>, Int32)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)

Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(String, IFormatProvider, Int32)
TryParse(String, Int32)

Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem. Vrácená hodnota označuje, zda byl převod úspěšný.

TryParse(String, NumberStyles, IFormatProvider, Int32)

Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselné ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.

Explicitní implementace rozhraní

IBinaryInteger<Int32>.GetByteCount()

Získá počet bajtů, které budou zapsány jako součást TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<Int32>.GetShortestBitLength()

Získá délku v bitech nejkratšího dvou doplňku reprezentace aktuální hodnoty.

IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)

Pokusí se napsat aktuální hodnotu ve formátu big-endian do daného rozsahu.

IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)

Pokusí se napsat aktuální hodnotu v malém endiánském formátu do daného rozsahu.

IComparable.CompareTo(Object)

Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.

IConvertible.GetTypeCode()

TypeCode Vrátí hodnotu pro typ Int32hodnoty .

IConvertible.ToBoolean(IFormatProvider)

Popis tohoto člena najdete v tématu ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena najdete v tématu ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Popis tohoto člena najdete v tématu ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Tento převod není podporován. Pokus o použití této metody vyvolá InvalidCastExceptionchybu .

IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena najdete v tématu ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena najdete v tématu ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena najdete v tématu ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena najdete v tématu ToSingle(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena najdete v tématu ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider).

Platí pro

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také