99

Wie konvertiere ich uint in C # in int?

c#

— Lieven Cardoen
quelle

5

Beachten Sie, dass Sie in diesem Fall den Wert eines int überlaufen können.

— Powerlord

1

Ja, Sie müssen sicherstellen, dass Sie die Ausnahme ordnungsgemäß behandeln, indem Sie Ihr Objekt in einen akzeptablen Zustand versetzen, wenn der Wert von uint größer als Int32.MaxValue ist (was zufällig 2.147.483.647 ist)

— Michael Meadows

Es wäre sicherer, die uintin eine longals longDose umzuwandeln, die alle uintWerte enthält , in denen als intnicht ( wie bereits erwähnt )

— Liam

186

Gegeben:

 uint n = 3;

int i = checked((int)n); //throws OverflowException if n > Int32.MaxValue
int i = unchecked((int)n); //converts the bits only 
                           //i will be negative if n > Int32.MaxValue

int i = (int)n; //same behavior as unchecked

oder

int i = Convert.ToInt32(n); //same behavior as checked

--BEARBEITEN

Enthaltene Informationen wie von Kenan EK erwähnt

— Samuel Carrijo
quelle

4

Beachten Sie, dass wenn das uintgrößer ist als, int.MaxValueSie ein negatives Ergebnis erhalten, wenn Sie eine Besetzung verwenden, oder eine Ausnahme, wenn Sie verwenden Convert.ToInt32.

— LukeH

4

Das macht Convert.ToInt32 imo zur besseren Wahl.

— mmcdole

4

@ Luke - Nein, nicht unbedingt. Beim Casting hängt es von Ihren Projekterstellungseinstellungen ab, ob die Option "Aktiviert" oder "Nicht aktiviert" aktiviert ist. Darüber hinaus können Sie dies lokal mit den aktivierten und deaktivierten Schlüsselwörtern ändern.

— Greg Beech

@ Greg: Das stimmt, aber die Standardeinstellung ist nicht aktiviert.

— LukeH

@ GregBeech Ist dieses Verhalten portabel? im Falle eines ungeprüften Ansatzes?

12

Beachten Sie die Schlüsselwörter checkedund unchecked.

Es ist wichtig, ob das Ergebnis auf int abgeschnitten oder eine Ausnahme ausgelöst werden soll, wenn das Ergebnis nicht in vorzeichenbehaftete 32 Bit passt. Die Standardeinstellung ist deaktiviert.

— Kenan EK
quelle

2

Ich glaube, die Standardeinstellung ist deaktiviert. +1 für den Hinweis - die Quelle für schwer zu debuggende Fehler.

Du hast recht, mein Schlechtes, danke! - "Der Standardwert für diese Option ist / markiert-"

— Kenan EK

Deaktiviert wird nicht "abgeschnitten".

— Fraktor

9

Angenommen, Sie möchten einfach die 32 Bits von einem Typ abheben und sie unverändert in den anderen Typ ablegen:

uint asUint = unchecked((uint)myInt);
int asInt = unchecked((int)myUint);

Der Zieltyp wählt blind die 32 Bits aus und interpretiert sie neu.

Umgekehrt, wenn Sie mehr daran interessiert sind, die Dezimal- / Zahlenwerte im Bereich des Zieltyps selbst zu halten:

uint asUint = checked((uint)myInt);
int asInt = checked((int)myUint);

In diesem Fall erhalten Sie Überlaufausnahmen, wenn:

Wirken eines negativen int (zB: -1) in ein uint
Wirken eines positiven Uint zwischen 2.147.483.648 und 4.294.967.295 auf einen Int

In unserem Fall wollten wir, dass die unchecked32-Bit-Version unverändert bleibt. Hier einige Beispiele:

Beispiele

int => uint

int....: 0000000000 (00-00-00-00)
asUint.: 0000000000 (00-00-00-00)
------------------------------
int....: 0000000001 (01-00-00-00)
asUint.: 0000000001 (01-00-00-00)
------------------------------
int....: -0000000001 (FF-FF-FF-FF)
asUint.: 4294967295 (FF-FF-FF-FF)
------------------------------
int....: 2147483647 (FF-FF-FF-7F)
asUint.: 2147483647 (FF-FF-FF-7F)
------------------------------
int....: -2147483648 (00-00-00-80)
asUint.: 2147483648 (00-00-00-80)

uint => int

uint...: 0000000000 (00-00-00-00)
asInt..: 0000000000 (00-00-00-00)
------------------------------
uint...: 0000000001 (01-00-00-00)
asInt..: 0000000001 (01-00-00-00)
------------------------------
uint...: 2147483647 (FF-FF-FF-7F)
asInt..: 2147483647 (FF-FF-FF-7F)
------------------------------
uint...: 4294967295 (FF-FF-FF-FF)
asInt..: -0000000001 (FF-FF-FF-FF)
------------------------------

Code

int[] testInts = { 0, 1, -1, int.MaxValue, int.MinValue };
uint[] testUints = { uint.MinValue, 1, uint.MaxValue / 2, uint.MaxValue };

foreach (var Int in testInts)
{
    uint asUint = unchecked((uint)Int);
    Console.WriteLine("int....: {0:D10} ({1})", Int, BitConverter.ToString(BitConverter.GetBytes(Int)));
    Console.WriteLine("asUint.: {0:D10} ({1})", asUint, BitConverter.ToString(BitConverter.GetBytes(asUint)));
    Console.WriteLine(new string('-',30));
}
Console.WriteLine(new string('=', 30));
foreach (var Uint in testUints)
{
    int asInt = unchecked((int)Uint);
    Console.WriteLine("uint...: {0:D10} ({1})", Uint, BitConverter.ToString(BitConverter.GetBytes(Uint)));
    Console.WriteLine("asInt..: {0:D10} ({1})", asInt, BitConverter.ToString(BitConverter.GetBytes(asInt)));
    Console.WriteLine(new string('-', 30));
}

— DeepSpace101
quelle

7

Convert.ToInt32()nimmt uintals Wert.

— NikolaiDante
quelle

0

Angenommen, der in uint enthaltene Wert kann in einem int dargestellt werden, dann ist es so einfach wie:

int val = (int) uval;

— julianisch
quelle

0

Ich würde sagen, wenn Sie tryParse verwenden, wird 'false' zurückgegeben, wenn das uint für ein int zu groß ist.
Vergessen Sie nicht, dass ein Uint viel größer als ein Int sein kann, solange Sie> 0 gehen

— BlueCacti
quelle

0

uint i = 10;
int j = (int)i;

oder

int k = Convert.ToInt32(i)

— Chris Mullins
quelle

-1

int intNumber = (int)uintNumber;

Abhängig davon, welche Art von Werten Sie erwarten, möchten Sie möglicherweise vor der Konvertierung überprüfen, wie groß uintNumber ist. Ein int hat einen Maximalwert von ungefähr 0,5 eines uint.

— Jesse Vogt
quelle