BitVector32 BitVector32 BitVector32 BitVector32 Struct

Definizione

Fornisce una struttura semplice che consente di memorizzare valori Boolean e Small Integer in 32 bit di memoria.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
Ereditarietà
BitVector32BitVector32BitVector32BitVector32

Esempi

Nell'esempio di codice seguente viene BitVector32 usato un oggetto come raccolta di flag di bit.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}

Nell'esempio di codice seguente viene BitVector32 usato un oggetto come raccolta di sezioni.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

Commenti

BitVector32è più efficiente di BitArray per i valori booleani e i numeri interi piccoli usati internamente.BitVector32 is more efficient than BitArray for Boolean values and small integers that are used internally. Un BitArray può crescere indefinitamente in base alle esigenze, ma presenta il sovraccarico di memoria e prestazioni richiesto da un'istanza della classe.A BitArray can grow indefinitely as needed, but it has the memory and performance overhead that a class instance requires. Al contrario, un BitVector32 utilizza solo 32 bit.In contrast, a BitVector32 uses only 32 bits.

Una BitVector32 struttura può essere configurata in modo da contenere le sezioni per numeri interi piccoli o flag di bit per i valori booleani, ma non per entrambi.A BitVector32 structure can be set up to contain either sections for small integers or bit flags for Booleans, but not both. Un BitVector32.Section oggetto è una finestra nell' BitVector32 oggetto ed è costituito dal più piccolo numero di bit consecutivi che può contenere il valore massimo CreateSectionspecificato in.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. Ad esempio, una sezione con un valore massimo pari a 1 è costituita da un solo bit, mentre una sezione con un valore massimo pari a 5 è costituita da tre bit.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. È possibile creare un BitVector32.Section con un valore massimo di 1 per fungere da valore booleano, consentendo così di archiviare numeri interi e valori booleani BitVector32nello stesso oggetto.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.

Alcuni membri possono essere utilizzati per un BitVector32 oggetto configurato come sezioni, mentre altri membri possono essere utilizzati per uno configurato come flag di bit.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. Ad esempio, la BitVector32.Item[Int32] proprietà è l'indicizzatore per un BitVector32 oggetto configurato come sezioni e la BitVector32.Item[Int32] proprietà è l'indicizzatore per un oggetto BitVector32 configurato come flag di bit.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. CreateMaskCrea una serie di maschere che possono essere usate per accedere ai singoli bit in BitVector32 un oggetto configurato come flag di bit.CreateMask creates a series of masks that can be used to access individual bits in a BitVector32 that is set up as bit flags.

L'uso di una maschera BitVector32 su un oggetto configurato come sezioni può causare risultati imprevisti.Using a mask on a BitVector32 that is set up as sections might cause unexpected results.

Costruttori

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

Inizializza una nuova istanza della struttura BitVector32 che contiene i dati rappresentati in una struttura BitVector32 esistente.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)

Inizializza una nuova istanza della struttura BitVector32 che contiene i dati rappresentati in un intero.Initializes a new instance of the BitVector32 structure containing the data represented in an integer.

Proprietà

Data Data Data Data

Ottiene il valore della struttura BitVector32 sotto forma di intero.Gets the value of the BitVector32 as an integer.

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

Ottiene o imposta il valore memorizzato nella struttura BitVector32.Section specificata.Gets or sets the value stored in the specified BitVector32.Section.

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

Ottiene o imposta lo stato del flag di bit indicato dalla maschera specificata.Gets or sets the state of the bit flag indicated by the specified mask.

Metodi

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

Crea la prima di una serie di maschere che possono essere utilizzate per recuperare i singoli bit di una struttura BitVector32 configurata come flag di bit.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)

Crea una maschera aggiuntiva, successiva alla maschera specificata all'interno di una serie, che è possibile utilizzare per recuperare i singoli bit di una struttura BitVector32 impostata come flag di bit.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)

Crea la prima sezione BitVector32.Section di una serie di sezioni che contengono Small Integer.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)

Crea una nuova sezione BitVector32.Section, successiva a quella specificata BitVector32.Section in una serie di sezioni che contengono Small Integer.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)

Determina se l'oggetto specificato è uguale alla struttura BitVector32.Determines whether the specified object is equal to the BitVector32.

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

Viene utilizzato come funzione hash per la struttura BitVector32.Serves as a hash function for the BitVector32.

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

Restituisce una stringa che rappresenta l'oggetto BitVector32 corrente.Returns a string that represents the current BitVector32.

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

Restituisce una stringa che rappresenta l'oggetto BitVector32 specificato.Returns a string that represents the specified BitVector32.

Si applica a

Vedi anche