Double-Struktur

Artikel
08/20/2007

Stellt eine Gleitkommazahl mit doppelter Genauigkeit dar.

Namespace: System
Assembly: mscorlib (in mscorlib.dll)

Syntax

'Declaration
<SerializableAttribute> _
<ComVisibleAttribute(True)> _
Public Structure Double
    Implements IComparable, IFormattable, IConvertible, IComparable(Of Double), _
    IEquatable(Of Double)
'Usage
Dim instance As Double

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public struct Double : IComparable, IFormattable, IConvertible, 
    IComparable<double>, IEquatable<double>

[SerializableAttribute] 
[ComVisibleAttribute(true)] 
public value class Double : IComparable, IFormattable, IConvertible, 
    IComparable<double>, IEquatable<double>

/** @attribute SerializableAttribute() */ 
/** @attribute ComVisibleAttribute(true) */ 
public final class Double extends ValueType implements IComparable, IFormattable, 
    IConvertible, IComparable<double>, IEquatable<double>

JScript unterstützt die Verwendung von Strukturen, aber nicht die Deklaration von neuen Strukturen.

Hinweise

Der Werttyp Double stellt eine 64-Bit-Zahl doppelter Genauigkeit mit Werten von -1,79769313486232e308 bis +1,79769313486232e308 dar. Zum Wertebereich gehören weiterhin eine positive und eine negative 0 (null), PositiveInfinity, NegativeInfinity und NaN (Not-a-Number, NaN).

Double entspricht der Norm IEC 60559:1989 (IEEE 754) für binäre Gleitkomma-Arithmetik.

Double stellt Methoden zum Vergleichen von Instanzen dieses Typs, zum Konvertieren des Werts einer Instanz in die entsprechende Zeichenfolgendarstellung und zum Konvertieren der Zeichenfolgenentsprechung einer Zahl in eine Instanz dieses Typs bereit. Informationen über die Steuerung der Zeichenfolgenentsprechung von Werttypen mit Codes für die Formatangabe finden Sie unter Übersicht über Formatierung, Standardmäßige Zahlenformatzeichenfolgen und Benutzerdefinierte Zahlenformatzeichenfolgen.

Verwenden von Gleitkommazahlen

Wenn bei einer binären Operation einer der Operanden ein Double ist, muss der andere Operand ein ganzzahliger Typ oder ein Gleitkommatyp sein (Double oder Single). Wenn der andere Operand kein Double ist, wird er vor Ausführung der Operation in Double konvertiert, und bei Ausführung der Operation werden mindestens der Wertebereich und die Genauigkeit von Double verwendet. Wenn das Ergebnis der Operation numerisch ist, ist der Ergebnistyp Double.

Gleitkommaoperatoren einschließlich des Zuweisungsoperators lösen keine Ausnahmen aus. Stattdessen ist, wie unten beschrieben, das Ergebnis einer Gleitkommaoperation in Ausnahmefällen 0 (null), unendlich oder NaN:

Wenn der Betrag des Ergebnisses einer Gleitkommaoperation für das Zielformat zu klein ist, ist das Ergebnis der Operation 0 (null).
Wenn der Betrag des Ergebnisses einer Gleitkommaoperation zu groß für das Zielformat ist, ist das Ergebnis der Operation je nach Vorzeichen des Ergebnisses entweder PositiveInfinity oder NegativeInfinity.
Wenn eine Gleitkommaoperation ungültig ist, ist das Ergebnis der Operation NaN.
Wenn mindestens einer der Operanden einer Gleitkommaoperation NaN ist, ist das Ergebnis der Operation NaN.

Beachten Sie, dass eine Gleitkommazahl nur ein Näherungswert einer Dezimalzahl ist und dass die Genauigkeit einer Gleitkommazahl bestimmt, wie genau die Zahl mit einer Dezimalzahl übereinstimmt. In der Standardeinstellung hat der Double-Wert nur eine Genauigkeit von 15 Ziffern, obwohl intern maximal 17 gültige Ziffern bestimmt werden. Die Genauigkeit einer Gleitkommazahl hat mehrere Auswirkungen:

Zwei Gleitkommazahlen, die bei einer bestimmten Genauigkeit als gleich gelten, können bei einer anderen Genauigkeit als ungleich gelten, da sich die letzten signifikanten Ziffern unterscheiden.
Eine mathematische oder Vergleichsoperation, bei der eine Gleitkommazahl verwendet wird, führt möglicherweise nicht zu demselben Ergebnis wie bei der Verwendung einer Dezimalzahl, da die Gleitkommazahl eventuell nur ein Näherungswert der Dezimalzahl ist.
Bei Verwendung einer Gleitkommazahl könnte ein Wert möglicherweise nicht wiederhergestellt werden. Ein Wert gilt als wiederhergestellt, wenn er in einer Operation in ein anderes Format und anschließend in einer Umkehroperation wieder zu einer Gleitkommazahl konvertiert wird, wobei die resultierende Gleitkommazahl mit der ursprünglichen Gleitkommazahl übereinstimmt. Die Wiederherstellung könnte fehlschlagen, wenn ein oder mehr niederstwertige Ziffern bei einer Konvertierung verloren gehen oder geändert werden.

Schnittstellenimplementierungen

Dieser Typ implementiert die Schnittstellen IComparable, IComparable, IFormattable und IConvertible. Verwenden Sie für Konvertierungen die Convert-Klasse anstelle der expliziten Implementierung der Schnittstellenmember der IConvertible-Schnittstelle für diesen Typ.

Beispiel

Das folgende Codebeispiel veranschaulicht die Verwendung von Double:

' Temperature class stores the value as Double
' and delegates most of the functionality 
' to the Double implementation.
Public Class Temperature
    Implements IComparable, IFormattable

    Public Overloads Function CompareTo(ByVal obj As Object) As Integer _
        Implements IComparable.CompareTo

        If TypeOf obj Is Temperature Then
            Dim temp As Temperature = CType(obj, Temperature)

            Return m_value.CompareTo(temp.m_value)
        End If

        Throw New ArgumentException("object is not a Temperature")
    End Function

    Public Overloads Function ToString(ByVal format As String, ByVal provider As IFormatProvider) As String _
        Implements IFormattable.ToString

        If Not (format Is Nothing) Then
            If format.Equals("F") Then
                Return [String].Format("{0}'F", Me.Value.ToString())
            End If
            If format.Equals("C") Then
                Return [String].Format("{0}'C", Me.Celsius.ToString())
            End If
        End If

        Return m_value.ToString(format, provider)
    End Function

    ' Parses the temperature from a string in form
    ' [ws][sign]digits['F|'C][ws]
    Public Shared Function Parse(ByVal s As String, ByVal styles As NumberStyles, ByVal provider As IFormatProvider) As Temperature
        Dim temp As New Temperature()

        If s.TrimEnd(Nothing).EndsWith("'F") Then
            temp.Value = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
        Else
            If s.TrimEnd(Nothing).EndsWith("'C") Then
                temp.Celsius = Double.Parse(s.Remove(s.LastIndexOf("'"c), 2), styles, provider)
            Else
                temp.Value = Double.Parse(s, styles, provider)
            End If
        End If
        Return temp
    End Function

    ' The value holder
    Protected m_value As Double

    Public Property Value() As Double
        Get
            Return m_value
        End Get
        Set(ByVal Value As Double)
            m_value = Value
        End Set
    End Property

    Public Property Celsius() As Double
        Get
            Return (m_value - 32) / 1.8
        End Get
        Set(ByVal Value As Double)
            m_value = Value * 1.8 + 32
        End Set
    End Property
End Class

/// <summary>
/// Temperature class stores the value as Double
/// and delegates most of the functionality 
/// to the Double implementation.
/// </summary>
public class Temperature : IComparable, IFormattable {
    /// <summary>
    /// IComparable.CompareTo implementation.
    /// </summary>
    public int CompareTo(object obj) {
        if(obj is Temperature) {
            Temperature temp = (Temperature) obj;

            return m_value.CompareTo(temp.m_value);
        }
        
        throw new ArgumentException("object is not a Temperature");    
    }

    /// <summary>
    /// IFormattable.ToString implementation.
    /// </summary>
    public string ToString(string format, IFormatProvider provider) {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    /// <summary>
    /// Parses the temperature from a string in form
    /// [ws][sign]digits['F|'C][ws]
    /// </summary>
    public static Temperature Parse(string s, NumberStyles styles, IFormatProvider provider) {
        Temperature temp = new Temperature();

        if( s.TrimEnd(null).EndsWith("'F") ) {
            temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else if( s.TrimEnd(null).EndsWith("'C") ) {
            temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else {
            temp.Value = Double.Parse(s, styles, provider);
        }

        return temp;
    }

    // The value holder
    protected double m_value;

    public double Value {
        get {
            return m_value;
        }
        set {
            m_value = value;
        }
    }

    public double Celsius {
        get {
            return (m_value-32.0)/1.8;
        }
        set {
            m_value = 1.8*value+32.0;
        }
    }
}

/// <summary>
/// Temperature class stores the value as Double
/// and delegates most of the functionality 
/// to the Double implementation.
/// </summary>
public ref class Temperature: public IComparable, public IFormattable
{
   /// <summary>
   /// IComparable.CompareTo implementation.
   /// </summary>
public:
   virtual int CompareTo( Object^ obj )
   {
      if ( dynamic_cast<Temperature^>(obj) )
      {
         Temperature^ temp = (Temperature^)(obj);
         return m_value.CompareTo( temp->m_value );
      }

      throw gcnew ArgumentException( "object is not a Temperature" );
   }

   /// <summary>
   /// IFormattable.ToString implementation.
   /// </summary>
   virtual String^ ToString( String^ format, IFormatProvider^ provider )
   {
      if ( format != nullptr )
      {
         if ( format->Equals( "F" ) )
         {
            return String::Format( "{0}'F", this->Value.ToString() );
         }

         if ( format->Equals( "C" ) )
         {
            return String::Format( "{0}'C", this->Celsius.ToString() );
         }
      }

      return m_value.ToString( format, provider );
   }


   /// <summary>
   /// Parses the temperature from a string in form
   /// [ws][sign]digits['F|'C][ws]
   /// </summary>
   static Temperature^ Parse( String^ s, NumberStyles styles, IFormatProvider^ provider )
   {
      Temperature^ temp = gcnew Temperature;

      if ( s->TrimEnd( 0 )->EndsWith( "'F" ) )
      {
         temp->Value = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      if ( s->TrimEnd( 0 )->EndsWith( "'C" ) )
      {
         temp->Celsius = Double::Parse( s->Remove( s->LastIndexOf( '\'' ), 2 ), styles, provider );
      }
      else
      {
         temp->Value = Double::Parse( s, styles, provider );
      }

      return temp;
   }

protected:
   // The value holder
   double m_value;

public:
   property double Value 
   {
      double get()
      {
         return m_value;
      }
      void set( double value )
      {
         m_value = value;
      }

   }

   property double Celsius 
   {
      double get()
      {
         return (m_value - 32.0) / 1.8;
      }
      void set( double value )
      {
         m_value = 1.8 * value + 32.0;
      }

   }

};

/// <summary>
/// Temperature class stores the value as Double
/// and delegates most of the functionality 
/// to the Double implementation.
/// </summary>
public class Temperature implements IComparable, IFormattable {
    /// <summary>
    /// IComparable.CompareTo implementation.
    /// </summary>
    public function CompareTo(obj) : int{
        if(obj.GetType() == Temperature) {
            var temp : Temperature = Temperature(obj);

            return m_value.CompareTo(temp.m_value);
        }
        
        throw new ArgumentException("object is not a Temperature");    
    }

    /// <summary>
    /// IFormattable.ToString implementation.
    /// </summary>
    public function ToString(format : String, provider : IFormatProvider) : String {
        if( format != null ) {
            if( format.Equals("F") ) {
                return String.Format("{0}'F", this.Value.ToString());
            }
            if( format.Equals("C") ) {
                return String.Format("{0}'C", this.Celsius.ToString());
            }
        }

        return m_value.ToString(format, provider);
    }

    /// <summary>
    /// Parses the temperature from a string in form
    /// [ws][sign]digits['F|'C][ws]
    /// </summary>
    public static function Parse(s : String, styles : NumberStyles, provider : IFormatProvider) : Temperature{
        var temp : Temperature = new Temperature();

        if( s.TrimEnd(null).EndsWith("'F") ) {
            temp.Value = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else if( s.TrimEnd(null).EndsWith("'C") ) {
            temp.Celsius = Double.Parse( s.Remove(s.LastIndexOf('\''), 2), styles, provider);
        }
        else {
            temp.Value = Double.Parse(s, styles, provider);
        }

        return temp;
    }

    // The value holder
    protected var m_value : double;

    public function get Value() : double{
        return m_value;
    }
    
            public function set Value(value : double) {
        m_value = value;
    }

    public function get Celsius() : double {
        return (m_value-32.0)/1.8;
            }
            
            public function set Celsius(value : double) {
        m_value = 1.8*value+32.0;
    }
}

Threadsicherheit

Alle öffentlichen statischen (Shared in Visual Basic) Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Plattformen

Windows 98, Windows 2000 SP4, Windows CE, Windows Millennium Edition, Windows Mobile für Pocket PC, Windows Mobile für Smartphone, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework unterstützt nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen.

Double-Struktur

Syntax

Hinweise

Verwenden von Gleitkommazahlen

Schnittstellenimplementierungen

Beispiel

Threadsicherheit

Plattformen

Versionsinformationen

.NET Framework

.NET Compact Framework

Siehe auch

Referenz

Zusätzliche Ressourcen