BitVector32 BitVector32 BitVector32 BitVector32 Struct

Definition

Stellt eine einfache Struktur bereit, die boolesche Werte und Small Integeres in 32 Speicherbits speichert.Provides a simple structure that stores Boolean values and small integers in 32 bits of memory.

public value class BitVector32
public struct BitVector32
type BitVector32 = struct
Public Structure BitVector32
Vererbung
BitVector32BitVector32BitVector32BitVector32

Beispiele

Im folgenden Codebeispiel wird eine BitVector32 als Auflistung von Bitflags verwendet.The following code example uses a BitVector32 as a collection of bit flags.

#using <system.dll>

using namespace System;
using namespace System::Collections::Specialized;
int main()
{
   
   // Creates and initializes a BitVector32 with all bit flags set to FALSE.
   BitVector32 myBV(0);
   
   // Creates masks to isolate each of the first five bit flags.
   int myBit1 = BitVector32::CreateMask();
   int myBit2 = BitVector32::CreateMask( myBit1 );
   int myBit3 = BitVector32::CreateMask( myBit2 );
   int myBit4 = BitVector32::CreateMask( myBit3 );
   int myBit5 = BitVector32::CreateMask( myBit4 );
   
   // Sets the alternating bits to TRUE.
   Console::WriteLine( "Setting alternating bits to TRUE:" );
   Console::WriteLine( "   Initial:       {0}", myBV );
   myBV[ myBit1 ] = true;
   Console::WriteLine( "   myBit1 = TRUE: {0}", myBV );
   myBV[ myBit3 ] = true;
   Console::WriteLine( "   myBit3 = TRUE: {0}", myBV );
   myBV[ myBit5 ] = true;
   Console::WriteLine( "   myBit5 = TRUE: {0}", myBV );
}

/*
This code produces the following output.

Setting alternating bits to TRUE:
Initial:         BitVector32 {00000000000000000000000000000000}
myBit1 = TRUE:   BitVector32 {00000000000000000000000000000001}
myBit3 = TRUE:   BitVector32 {00000000000000000000000000000101}
myBit5 = TRUE:   BitVector32 {00000000000000000000000000010101}


*/
using System;
using System.Collections.Specialized;


public class SamplesBitVector32  {

   public static void Main()  {

      // Creates and initializes a BitVector32 with all bit flags set to FALSE.
      BitVector32 myBV = new BitVector32( 0 );

      // Creates masks to isolate each of the first five bit flags.
      int myBit1 = BitVector32.CreateMask();
      int myBit2 = BitVector32.CreateMask( myBit1 );
      int myBit3 = BitVector32.CreateMask( myBit2 );
      int myBit4 = BitVector32.CreateMask( myBit3 );
      int myBit5 = BitVector32.CreateMask( myBit4 );

      // Sets the alternating bits to TRUE.
      Console.WriteLine( "Setting alternating bits to TRUE:" );
      Console.WriteLine( "   Initial:         {0}", myBV.ToString() );
      myBV[myBit1] = true;
      Console.WriteLine( "   myBit1 = TRUE:   {0}", myBV.ToString() );
      myBV[myBit3] = true;
      Console.WriteLine( "   myBit3 = TRUE:   {0}", myBV.ToString() );
      myBV[myBit5] = true;
      Console.WriteLine( "   myBit5 = TRUE:   {0}", myBV.ToString() );

   }

}

/*
This code produces the following output.

Setting alternating bits to TRUE:
   Initial:         BitVector32{00000000000000000000000000000000}
   myBit1 = TRUE:   BitVector32{00000000000000000000000000000001}
   myBit3 = TRUE:   BitVector32{00000000000000000000000000000101}
   myBit5 = TRUE:   BitVector32{00000000000000000000000000010101}


*/
Imports System.Collections.Specialized

Public Class SamplesBitVector32

   Public Shared Sub Main()

      ' Creates and initializes a BitVector32 with all bit flags set to FALSE.
      Dim myBV As New BitVector32(0)

      ' Creates masks to isolate each of the first five bit flags.
      Dim myBit1 As Integer = BitVector32.CreateMask()
      Dim myBit2 As Integer = BitVector32.CreateMask(myBit1)
      Dim myBit3 As Integer = BitVector32.CreateMask(myBit2)
      Dim myBit4 As Integer = BitVector32.CreateMask(myBit3)
      Dim myBit5 As Integer = BitVector32.CreateMask(myBit4)

      ' Sets the alternating bits to TRUE.
      Console.WriteLine("Setting alternating bits to TRUE:")
      Console.WriteLine("   Initial:         {0}", myBV.ToString())
      myBV(myBit1) = True
      Console.WriteLine("   myBit1 = TRUE:   {0}", myBV.ToString())
      myBV(myBit3) = True
      Console.WriteLine("   myBit3 = TRUE:   {0}", myBV.ToString())
      myBV(myBit5) = True
      Console.WriteLine("   myBit5 = TRUE:   {0}", myBV.ToString())
   End Sub 'Main 
End Class 'SamplesBitVector32


' This code produces the following output.
'
' Setting alternating bits to TRUE:
'    Initial:         BitVector32{00000000000000000000000000000000}
'    myBit1 = TRUE:   BitVector32{00000000000000000000000000000001}
'    myBit3 = TRUE:   BitVector32{00000000000000000000000000000101}
'    myBit5 = TRUE:   BitVector32{00000000000000000000000000010101}

Im folgenden Codebeispiel wird eine BitVector32 als Auflistung von Abschnitten verwendet.The following code example uses a BitVector32 as a collection of sections.

#using <system.dll>

using namespace System;
using namespace System::Collections::Specialized;

int main()
{
   // Creates and initializes a BitVector32.
   BitVector32 myBV(0);

   // Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
   // mySect3, which uses exactly one bit, can also be used as a bit flag.
   BitVector32::Section mySect1 = BitVector32::CreateSection( 6 );
   BitVector32::Section mySect2 = BitVector32::CreateSection( 3, mySect1 );
   BitVector32::Section mySect3 = BitVector32::CreateSection( 1, mySect2 );
   BitVector32::Section mySect4 = BitVector32::CreateSection( 15, mySect3 );

   // Displays the values of the sections.
   Console::WriteLine( "Initial values:" );
   Console::WriteLine( "\tmySect1: {0}", myBV[ mySect1 ] );
   Console::WriteLine( "\tmySect2: {0}", myBV[ mySect2 ] );
   Console::WriteLine( "\tmySect3: {0}", myBV[ mySect3 ] );
   Console::WriteLine( "\tmySect4: {0}", myBV[ mySect4 ] );

   // Sets each section to a new value and displays the value of the BitVector32 at each step.
   Console::WriteLine( "Changing the values of each section:" );
   Console::WriteLine( "\tInitial:    \t {0}", myBV );
   myBV[ mySect1 ] = 5;
   Console::WriteLine( "\tmySect1 = 5:\t {0}", myBV );
   myBV[ mySect2 ] = 3;
   Console::WriteLine( "\tmySect2 = 3:\t {0}", myBV );
   myBV[ mySect3 ] = 1;
   Console::WriteLine( "\tmySect3 = 1:\t {0}", myBV );
   myBV[ mySect4 ] = 9;
   Console::WriteLine( "\tmySect4 = 9:\t {0}", myBV );

   // Displays the values of the sections.
   Console::WriteLine( "New values:" );
   Console::WriteLine( "\tmySect1: {0}", myBV[ mySect1 ] );
   Console::WriteLine( "\tmySect2: {0}", myBV[ mySect2 ] );
   Console::WriteLine( "\tmySect3: {0}", myBV[ mySect3 ] );
   Console::WriteLine( "\tmySect4: {0}", myBV[ mySect4 ] );
}

/*
This code produces the following output.

Initial values:
        mySect1: 0
        mySect2: 0
        mySect3: 0
        mySect4: 0
Changing the values of each section:
        Initial:        BitVector32 {00000000000000000000000000000000}
        mySect1 = 5:    BitVector32 {00000000000000000000000000000101}
        mySect2 = 3:    BitVector32 {00000000000000000000000000011101}
        mySect3 = 1:    BitVector32 {00000000000000000000000000111101}
        mySect4 = 9:    BitVector32 {00000000000000000000001001111101}
New values:
        mySect1: 5
        mySect2: 3
        mySect3: 1
        mySect4: 9

*/
using System;
using System.Collections.Specialized;


public class SamplesBitVector32  {

   public static void Main()  {

      // Creates and initializes a BitVector32.
      BitVector32 myBV = new BitVector32( 0 );

      // Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
      // mySect3, which uses exactly one bit, can also be used as a bit flag.
      BitVector32.Section mySect1 = BitVector32.CreateSection( 6 );
      BitVector32.Section mySect2 = BitVector32.CreateSection( 3, mySect1 );
      BitVector32.Section mySect3 = BitVector32.CreateSection( 1, mySect2 );
      BitVector32.Section mySect4 = BitVector32.CreateSection( 15, mySect3 );

      // Displays the values of the sections.
      Console.WriteLine( "Initial values:" );
      Console.WriteLine( "\tmySect1: {0}", myBV[mySect1] );
      Console.WriteLine( "\tmySect2: {0}", myBV[mySect2] );
      Console.WriteLine( "\tmySect3: {0}", myBV[mySect3] );
      Console.WriteLine( "\tmySect4: {0}", myBV[mySect4] );

      // Sets each section to a new value and displays the value of the BitVector32 at each step.
      Console.WriteLine( "Changing the values of each section:" );
      Console.WriteLine( "\tInitial:    \t{0}", myBV.ToString() );
      myBV[mySect1] = 5;
      Console.WriteLine( "\tmySect1 = 5:\t{0}", myBV.ToString() );
      myBV[mySect2] = 3;
      Console.WriteLine( "\tmySect2 = 3:\t{0}", myBV.ToString() );
      myBV[mySect3] = 1;
      Console.WriteLine( "\tmySect3 = 1:\t{0}", myBV.ToString() );
      myBV[mySect4] = 9;
      Console.WriteLine( "\tmySect4 = 9:\t{0}", myBV.ToString() );

      // Displays the values of the sections.
      Console.WriteLine( "New values:" );
      Console.WriteLine( "\tmySect1: {0}", myBV[mySect1] );
      Console.WriteLine( "\tmySect2: {0}", myBV[mySect2] );
      Console.WriteLine( "\tmySect3: {0}", myBV[mySect3] );
      Console.WriteLine( "\tmySect4: {0}", myBV[mySect4] );

   }

}

/*
This code produces the following output.

Initial values:
        mySect1: 0
        mySect2: 0
        mySect3: 0
        mySect4: 0
Changing the values of each section:
        Initial:        BitVector32{00000000000000000000000000000000}
        mySect1 = 5:    BitVector32{00000000000000000000000000000101}
        mySect2 = 3:    BitVector32{00000000000000000000000000011101}
        mySect3 = 1:    BitVector32{00000000000000000000000000111101}
        mySect4 = 9:    BitVector32{00000000000000000000001001111101}
New values:
        mySect1: 5
        mySect2: 3
        mySect3: 1
        mySect4: 9

*/
Imports System.Collections.Specialized

Public Class SamplesBitVector32
   
   Public Shared Sub Main()
      
      ' Creates and initializes a BitVector32.
      Dim myBV As New BitVector32(0)
      
      ' Creates four sections in the BitVector32 with maximum values 6, 3, 1, and 15.
      ' mySect3, which uses exactly one bit, can also be used as a bit flag.
      Dim mySect1 As BitVector32.Section = BitVector32.CreateSection(6)
      Dim mySect2 As BitVector32.Section = BitVector32.CreateSection(3, mySect1)
      Dim mySect3 As BitVector32.Section = BitVector32.CreateSection(1, mySect2)
      Dim mySect4 As BitVector32.Section = BitVector32.CreateSection(15, mySect3)
      
      ' Displays the values of the sections.
      Console.WriteLine("Initial values:")
      Console.WriteLine(ControlChars.Tab + "mySect1: {0}", myBV(mySect1))
      Console.WriteLine(ControlChars.Tab + "mySect2: {0}", myBV(mySect2))
      Console.WriteLine(ControlChars.Tab + "mySect3: {0}", myBV(mySect3))
      Console.WriteLine(ControlChars.Tab + "mySect4: {0}", myBV(mySect4))
      
      ' Sets each section to a new value and displays the value of the BitVector32 at each step.
      Console.WriteLine("Changing the values of each section:")
      Console.WriteLine(ControlChars.Tab + "Initial:    " + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect1) = 5
      Console.WriteLine(ControlChars.Tab + "mySect1 = 5:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect2) = 3
      Console.WriteLine(ControlChars.Tab + "mySect2 = 3:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect3) = 1
      Console.WriteLine(ControlChars.Tab + "mySect3 = 1:" + ControlChars.Tab + "{0}", myBV.ToString())
      myBV(mySect4) = 9
      Console.WriteLine(ControlChars.Tab + "mySect4 = 9:" + ControlChars.Tab + "{0}", myBV.ToString())
      
      ' Displays the values of the sections.
      Console.WriteLine("New values:")
      Console.WriteLine(ControlChars.Tab + "mySect1: {0}", myBV(mySect1))
      Console.WriteLine(ControlChars.Tab + "mySect2: {0}", myBV(mySect2))
      Console.WriteLine(ControlChars.Tab + "mySect3: {0}", myBV(mySect3))
      Console.WriteLine(ControlChars.Tab + "mySect4: {0}", myBV(mySect4))

   End Sub 'Main 

End Class 'SamplesBitVector32


' This code produces the following output.
'
' Initial values:
'        mySect1: 0
'        mySect2: 0
'        mySect3: 0
'        mySect4: 0
' Changing the values of each section:
'        Initial:        BitVector32{00000000000000000000000000000000}
'        mySect1 = 5:    BitVector32{00000000000000000000000000000101}
'        mySect2 = 3:    BitVector32{00000000000000000000000000011101}
'        mySect3 = 1:    BitVector32{00000000000000000000000000111101}
'        mySect4 = 9:    BitVector32{00000000000000000000001001111101}
' New values:
'        mySect1: 5
'        mySect2: 3
'        mySect3: 1
'        mySect4: 9

Hinweise

BitVector32ist effizienter als BitArray bei booleschen Werten und kleinen Integern, die intern verwendet werden.BitVector32 is more efficient than BitArray for Boolean values and small integers that are used internally. Eine BitArray kann bei Bedarf unbegrenzt wachsen, aber Sie verfügt über den Arbeitsspeicher und den Leistungs Aufwand, der für eine Klasseninstanz erforderlich ist.A BitArray can grow indefinitely as needed, but it has the memory and performance overhead that a class instance requires. Im Gegensatz dazu verwendet BitVector32 eine nur 32 Bits.In contrast, a BitVector32 uses only 32 bits.

Eine BitVector32 Struktur kann so eingerichtet werden, dass Sie entweder Abschnitte für kleine Ganzzahlen oder Bitflags für boolesche Werte enthält, nicht jedoch beides.A BitVector32 structure can be set up to contain either sections for small integers or bit flags for Booleans, but not both. Ein BitVector32.Section ist ein Fenster in der BitVector32 und besteht aus der kleinsten Anzahl aufeinander folgender Bits, die den in CreateSectionangegebenen Höchstwert enthalten können.A BitVector32.Section is a window into the BitVector32 and is composed of the smallest number of consecutive bits that can contain the maximum value specified in CreateSection. Beispielsweise besteht ein Abschnitt mit einem maximalen Wert von 1 aus nur einem Bit, wohingegen ein Abschnitt mit einem maximalen Wert von 5 aus drei Bits besteht.For example, a section with a maximum value of 1 is composed of only one bit, whereas a section with a maximum value of 5 is composed of three bits. Sie können einen BitVector32.Section mit einem maximalen Wert von 1 erstellen, der als boolescher Wert fungiert, sodass Sie Ganzzahlen und boolesche Werte im gleichen BitVector32speichern können.You can create a BitVector32.Section with a maximum value of 1 to serve as a Boolean, thereby allowing you to store integers and Booleans in the same BitVector32.

Einige Member können für einen BitVector32 verwendet werden, der als Abschnitte eingerichtet ist, während andere Member für einen verwendet werden können, der als Bitflags eingerichtet ist.Some members can be used for a BitVector32 that is set up as sections, while other members can be used for one that is set up as bit flags. Beispielsweise ist die BitVector32.Item[Int32] -Eigenschaft der Indexer für einen BitVector32 , der als-Abschnitte eingerichtet ist, und BitVector32.Item[Int32] die-Eigenschaft ist der Indexer BitVector32 für einen, der als Bitflags eingerichtet ist.For example, the BitVector32.Item[Int32] property is the indexer for a BitVector32 that is set up as sections, and the BitVector32.Item[Int32] property is the indexer for a BitVector32 that is set up as bit flags. CreateMaskerstellt eine Reihe von Masken, die verwendet werden können, um auf einzelne Bits BitVector32 in einem zuzugreifen, der als Bitflags eingerichtet ist.CreateMask creates a series of masks that can be used to access individual bits in a BitVector32 that is set up as bit flags.

Die Verwendung einer Maske für BitVector32 einen, der als Abschnitte eingerichtet ist, kann zu unerwarteten Ergebnissen führen.Using a mask on a BitVector32 that is set up as sections might cause unexpected results.

Konstruktoren

BitVector32(BitVector32) BitVector32(BitVector32) BitVector32(BitVector32) BitVector32(BitVector32)

Initialisiert eine neue Instanz der BitVector32-Struktur, die die in einer vorhandenen BitVector32-Struktur dargestellten Daten enthält.Initializes a new instance of the BitVector32 structure containing the data represented in an existing BitVector32 structure.

BitVector32(Int32) BitVector32(Int32) BitVector32(Int32) BitVector32(Int32)

Initialisiert eine neue Instanz der BitVector32-Struktur, die die in einer Ganzzahl dargestellten Daten enthält.Initializes a new instance of the BitVector32 structure containing the data represented in an integer.

Eigenschaften

Data Data Data Data

Ruft den Wert der BitVector32-Struktur als Ganzzahl ab.Gets the value of the BitVector32 as an integer.

Item[BitVector32+Section] Item[BitVector32+Section] Item[BitVector32+Section] Item[BitVector32+Section]

Ruft den in der angegebenen BitVector32.Section-Struktur gespeicherten Wert ab oder legt diesen fest.Gets or sets the value stored in the specified BitVector32.Section.

Item[Int32] Item[Int32] Item[Int32] Item[Int32]

Ruft den Zustand des durch die angegebene Maske bezeichneten Bitflags ab oder legt diesen fest.Gets or sets the state of the bit flag indicated by the specified mask.

Methoden

CreateMask() CreateMask() CreateMask() CreateMask()

Erstellt die erste Maske aus einer Reihe von Masken, mit der einzelne Bits in einer BitVector32-Struktur abgerufen werden können, die in Form von Bitflags eingerichtet ist.Creates the first mask in a series of masks that can be used to retrieve individual bits in a BitVector32 that is set up as bit flags.

CreateMask(Int32) CreateMask(Int32) CreateMask(Int32) CreateMask(Int32)

Erstellt in einer Reihe von Masken hinter der angegebenen Maske eine zusätzliche Maske, mit der einzelne Bits in einer BitVector32-Struktur abgerufen werden können, die in Form von Bitflags eingerichtet ist.Creates an additional mask following the specified mask in a series of masks that can be used to retrieve individual bits in a BitVector32 that is set up as bit flags.

CreateSection(Int16) CreateSection(Int16) CreateSection(Int16) CreateSection(Int16)

Erstellt die erste BitVector32.Section-Struktur in einer Reihe von Abschnitten, die Small Integers enthalten.Creates the first BitVector32.Section in a series of sections that contain small integers.

CreateSection(Int16, BitVector32+Section) CreateSection(Int16, BitVector32+Section) CreateSection(Int16, BitVector32+Section) CreateSection(Int16, BitVector32+Section)

Erstellt eine neue BitVector32.Section-Struktur hinter der angegebenen BitVector32.Section-Struktur in einer Reihe von Abschnitten, die Small Integers enthalten.Creates a new BitVector32.Section following the specified BitVector32.Section in a series of sections that contain small integers.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Bestimmt, ob das angegebene Objekt der BitVector32-Struktur entspricht.Determines whether the specified object is equal to the BitVector32.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Fungiert als eine Hashfunktion für die BitVector32-Struktur.Serves as a hash function for the BitVector32.

ToString() ToString() ToString() ToString()

Gibt eine Zeichenfolge zurück, die das aktuelle BitVector32-Objekt darstellt.Returns a string that represents the current BitVector32.

ToString(BitVector32) ToString(BitVector32) ToString(BitVector32) ToString(BitVector32)

Gibt eine Zeichenfolge zurück, die die angegebene BitVector32-Struktur darstellt.Returns a string that represents the specified BitVector32.

Gilt für:

Siehe auch