[JAVA] Lassen Sie uns die interne Darstellung einer Gleitkommazahl erhalten

Es ist in der Nähe, Kon'nichiwa! Dieses Mal werde ich vorstellen, wie man die interne Darstellung von Gleitkommazahlen erhält.

1. Was ist eine Gleitkommazahl?

Eine Gleitkommazahl ist eine Zahl, die einen Bruch mit einem Codeteil, einem Exponententeil und einem falschen Teil darstellt. In vielen Programmiersprachen wurde der Standard IEEE 754 übernommen, und die interne Darstellung ist in der Reihenfolge von Codeteil, Exponententeil und falschem Teil von oben angeordnet.

2. Lassen Sie uns die interne Darstellung von Gleitkommazahlen programmgesteuert abrufen

Hier werden wir einige Programme erstellen, die die interne Darstellung des Gleitkommatyps mit einfacher Genauigkeit (Gleitkommatyp) erhalten. Die Sprachen sind C, C ++, C #, VB.NET und Java.

2.1 Methode unter Verwendung eines gemeinsamen Körpers (C-Sprache, C ++)

In C-Sprache und C ++ wird ein ** Kommunal ** verwendet, der aus einer ** Float-Typ-Variablen ** und einer ** Int-Typ-Variablen ** mit derselben Datengröße wie der Float-Typ besteht. Da sich jedes Mitglied der Union im selben Speicherbereich befindet, können Sie die interne Darstellung des Float-Typ-Werts vom Int-Typ-Mitglied abrufen, indem Sie eine reelle Zahl in das Float-Typ-Mitglied einfügen.

float-bin.c

#include <stdio.h>

int main( void ) {

    /*Da die Datengröße des Float-Typs 32 Bit beträgt, wird sie mit dem 32-Bit-Integer-Typ (int) kombiniert.*/
    union { float f; int i; } a;
    int i;
    a.f = -2.5f;

    printf( "%f ( %08X )\n", a.f, a.i );
    
    /*Zeigen Sie eine Spalte mit Bits*/
    for( i = 31; i >= 0; i-- ){
        printf( "%d", ( a.i >> i ) & 1 );
    }
    printf( "\n" );
    
    /*Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).*/
    printf( "Codeteil: %X\n", ( a.i >> 31 ) & 1 );
    printf( "Indexteil: %X\n", ( a.i >> 23 ) & 0xFF );
    printf( "Formaler Teil: %X\n", a.i & 0x7FFFFF );

    return 0;
}

** Ausführungsergebnis ** -2.500000 ( C0200000 ) 11000000001000000000000000000000 Codeteil: 1 Indexteil: 80 Formeller Teil: 200000

• Es funktioniert auch mit C ++.

2.2 Methode mit Klassenfunktionen (C #, VB.NET, Java)

C # und VB.NET verwenden die .NET Framework ** BitConverter-Klasse **. Sie können die Methode ** BitConverter.GetBytes ** verwenden, um einen Float-Typ-Wert einmal in ein Byte-Typ-Array zu konvertieren, und dann die ** BitConverter.ToInt32 ** -Methode verwenden, um die interne Darstellung des Float-Typ-Werts abzurufen.

float-bin.cs

using System;

public class Program{
    public static void Main(){
        
        float f = -2.5f;
        // BitConverter.Die ToInt32-Methode verwendet ein Byte-Array und den ersten Index, der als Argumente konvertiert wird
        int i = BitConverter.ToInt32( BitConverter.GetBytes( f ), 0 );
        Console.WriteLine( "{0:F} ( {1:X8} )", f, i );
        
        //Zeigen Sie eine Spalte mit Bits
        for( int j = 31; j >= 0; j-- ){
            Console.Write( ( i >> j ) & 1 );
        }
        Console.WriteLine();
        
        //Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).
        Console.WriteLine( "Codeteil: {0:X}", ( i >> 31 ) & 1 );
        Console.WriteLine( "Indexteil: {0:X}", ( i >> 23 ) & 0xFF );
        Console.WriteLine( "Formaler Teil: {0:X}", i & 0x7FFFFF );
    }
}

float-bin.vb

Module Module1

    Sub Main()
		
	Dim f As Single = -2.5f
        ' BitConverter.Die ToInt32-Methode verwendet ein Byte-Array und den ersten Index, der als Argumente konvertiert wird
        Dim i As Integer = BitConverter.ToInt32( BitConverter.GetBytes( f ), 0 )
        Console.WriteLine( "{0:F} ( {1:X8} )", f, i )
        
        'Zeigen Sie eine Spalte mit Bits
        Dim j As Integer
        For j = 31 To 0 Step -1
            Console.Write( ( i >> j ) And 1 )
        Next
        Console.WriteLine()
        
        'Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).
        Console.WriteLine( "Codeteil: {0:X}", ( i >> 31 ) And 1 )
        Console.WriteLine( "Indexteil: {0:X}", ( i >> 23 ) And &HFF )
        Console.WriteLine( "Formaler Teil: {0:X}", i And &H7FFFFF )

        
    End Sub

End Module

Java verwendet die ** Float-Klasse **. Sie können die interne Darstellung eines Float-Typ-Werts mit der Methode ** Float.floatToIntBits ** abrufen.

float-bin.java

public class Main {
    public static void main(String[] args) throws Exception {
        
        float f = -2.5f;
        int i = Float.floatToIntBits( f );
        System.out.printf( "%f ( %08X )\n", f, i );
        
        //Zeigen Sie eine Spalte mit Bits
        for( int j = 31; j >= 0; j-- ){
            System.out.printf( "%d", ( i >> j ) & 1 );
        }
        System.out.println();
        
        //Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).
        System.out.printf( "Codeteil: %X\n", ( i >> 31 ) & 1 );
        System.out.printf( "Indexteil: %X\n", ( i >> 23 ) & 0xFF );
        System.out.printf( "Formaler Teil: %X\n", i & 0x7FFFFF );
        
    }
}

2.3 Methode mit Zeigerumwandlung (C-Sprache, C ++, C #)

In C-Sprache, C ++ und C # können Sie die interne Darstellung eines Float-Typ-Werts erhalten, indem Sie ** einen Float-Typ-Zeiger in einen Int-Typ-Zeiger ** umwandeln.

float-binptr.c

#include <stdio.h>

int main( void ) {

    float f = -2.5f;
    int i = *( ( int* )&f ), j;
    printf( "%f ( %08X )\n", f, i );
    
    /*Zeigen Sie eine Spalte mit Bits*/
    for( j = 31; j >= 0; j-- ){
        printf( "%d", ( i >> j ) & 1 );
    }
    printf( "\n" );
    
    /*Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).*/
    printf( "Codeteil: %X\n", ( i >> 31 ) & 1 );
    printf( "Indexteil: %X\n", ( i >> 23 ) & 0xFF );
    printf( "Formaler Teil: %X\n", i & 0x7FFFFF );

    return 0;
}

• Es funktioniert auch mit C ++.

In C # werden Zeiger als unsicherer Code behandelt und müssen mit der Option "** / unsicher **" kompiliert werden.

float-binptr.cs

using System;

public class Program {
	//Fügen Sie beim Umgang mit unsicherem Code das Schlüsselwort "unsicher" hinzu.
	public unsafe static void Main() {

		float f = -2.5f;
		int i = *( ( int* )&f );
		Console.WriteLine( "{0:F} ( {1:X8} )", f, i );

		//Zeigen Sie eine Spalte mit Bits
		for( int j = 31; j >= 0; j-- ) {
			Console.Write( ( i >> j ) & 1 );
		}
		Console.WriteLine();

		//Extrahieren Sie den Exponententeil (1 Bit), den Exponententeil (8 Bit) und den falschen Teil (23 Bit).
		Console.WriteLine( "Codeteil: {0:X}", ( i >> 31 ) & 1 );
		Console.WriteLine( "Indexteil: {0:X}", ( i >> 23 ) & 0xFF );
		Console.WriteLine( "Formaler Teil: {0:X}", i & 0x7FFFFF );
	}
}

3. Fazit

Dieses Mal habe ich ein Programm erstellt, um die interne Darstellung des Float-Typs anhand mehrerer Sprachen als Beispiele zu erhalten. Natürlich können Sie die interne Darstellung auf die gleiche Weise mit dem Doppeltyp erhalten.

Verwenden Sie es beispielsweise, wenn Sie die Berechnung von Gleitkommazahlen in einer Computerklasse beobachten.

Bis zum nächsten Mal!