System.Int32 – struktura

  • Článek

Tento článek obsahuje doplňující poznámky k referenční dokumentaci pro toto rozhraní API.

Int32 je neměnný typ hodnoty, který představuje celá čísla se míněnými čísly v rozsahu od záporných 2 147 483 648 (který je reprezentován konstantou Int32.MinValue ) až po kladné 2 147 483 647 (což je reprezentováno konstantou Int32.MaxValue ). .NET obsahuje také celočíselnou hodnotu bez znaménka, UInt32která představuje hodnoty v rozsahu 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 jí 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 hodnotu Int32 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 číselná Singlehodnota , Doublenebo Decimal hodnota, která obsahuje zlomkovou součást, 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ů tak, aby přiřadil proměnné 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 Int32 typu na hodnotu. To je možné, protože Int32 podporuje IConvertible rozhraní. Následující příklad znázorňuje 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 Int32 reprezentaci hodnoty na .Int32 Řetězec může obsahovat desetinné nebo šestnáctkové číslice. Následující příklad znázorňuje operaci analýzy 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í s hodnotami Int32

Typ Int32 podporuje standardní matematické operace, jako je sčítání, odčítání, dělení, násobení, negace a unární negace. Stejně jako ostatní celočíselné typy Int32 typ podporuje také bitové AND, 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 celočíselné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.)

Chcete-li naformátovat Int32 hodnotu jako celočíselný řetězec bez počáteční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 počátečních nul. Pomocí specifikátoru formátu "N" můžete zahrnout oddělovače skupin a zadat počet desetinných číslic, které se mají zobrazit v řetězcové reprezentaci čísla. Pomocí specifikátoru formátu "X" můžete reprezentovat 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 volá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 s celočíselnou hodnotou bez desetinné čárky

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í nebo šestnáctkovou reprezentací celočíselné hodnoty. Int32 hodnoty jsou reprezentovány v 31 bitech, přičemž třicetisekundový bit se používá jako znaménko. Kladné hodnoty jsou reprezentovány pomocí vyjádření 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 se dvěma ne desetinnými hodnotami, musí obě hodnoty používat stejnou reprezentaci.