Click on the banner to return to the Class Reference home page.

©Copyright 1996 Rogue Wave Software

RWGBitVec(size)

• Synopsis
• Description
• Persistence
• Example
• Public Constructors
• Assignment Operators
• Indexing Operators
• Public Member Functions
• Related Global Functions

#include <rw/gbitvec.h>

declare(RWGBitVec,size)
RWGBitVec(size) a;

RWGBitVec(size) is a bit vector of fixed length size. The length cannot be changed dynamically (see class RWBitVec if you need a bit vector whose length can be changed at run time). Objects of type RWGBitVec(size) are declared with macros defined in the standard C++ header file <generic.h>.

Bits are numbered from 0 through size-1, inclusive.

None

In this example, a bit vector 24 bits long is declared and exercised:

#include "rw/gbitvec.h"
#include <iostream.h>

const int VECSIZE = 8;

declare(RWGBitVec, VECSIZE)   // declare a 24 bit long vector
implement(RWGBitVec, VECSIZE) // implement the vector

main()
{ 
  RWGBitVec(VECSIZE) a, b;   // Allocate two vectors.

  a(2) = TRUE;               // Set bit 2 (the third bit) of a on.
  b(3) = TRUE;               // Set bit 3 (the fourth bit) of b on.

  RWGBitVec(VECSIZE) c = a ^ b;  // Set c to the XOR of a and b.

  cout << "Vector 1" << "\t" << "Vector 2" << "\t"
       << "Vector 1 xor Vector 2" << endl;

  for(int i = 0; i < VECSIZE; i++)
    cout << a[i] << "\t\t" << b[i] << "\t\t" << c[i] << endl;

  return 0;
}

RWGBitVec(size)();

Construct a bit vector size elements long, with all bits initialized to FALSE.

RWGBitVec(size)(RWBoolean f);

Construct a bit vector size elements long, with all bits initialized to f.

RWGBitVec(sz)&
operator=(const RWGBitVec(sz)& v);

Set each element of self to the corresponding bit value of v. Return a reference to self.

RWGBitVec(sz)&
operator=(RWBoolean f);

Set all elements of self to the boolean value f.

RWGBitVec(sz)&
operator&=(const RWGBitVec(sz)& v);
RWGBitVec(sz)&
operator^=(const RWGBitVec(sz)& v);
RWGBitVec(sz)&
operator|=(const RWGBitVec(sz)& v);

Logical assignments. Set each element of self to the logical AND, XOR, or OR, respectively, of self and the corresponding bit in v.

RWBitRef
operator[](size_t i);

Returns a reference to the ith bit of self. This reference can be used as an lvalue. The index i must be between 0 and size-1, inclusive. Bounds checking will occur.

RWBitRef
operator()(size_t i);

Returns a reference to the ith bit of self. This reference can be used as an lvalue. The index i must be between 0 and size-1, inclusive. No bounds checking is done.

void
clearBit(size_t i);

Clears (i.e., sets to FALSE) the bit with index i. The index i must be between 0 and size-1. No bounds checking is performed. The following are equivalent, although clearBit(size_t) is slightly smaller and faster than using operator()(size_t):

      a(i) = FALSE;

      a.clearBit(i);

const RWByte*
data() const;

Returns a const pointer to the raw data of self. Should be used with care.

void
setBit(size_t i);

Sets (i.e., sets to TRUE) the bit with index i. The index i must be between 0 and size-1. No bounds checking is performed. The following are equivalent, although setBit(size_t) is slightly smaller and faster than using operator()(size_t):

      a(i) = TRUE;

      a.setBit(i);

RWBoolean
testBit(size_t i) const;

Tests the bit with index i. The index i must be between 0 and size-1. No bounds checking is performed. The following are equivalent, although testBit(size_t) is slightly smaller and faster than using operator()(size_t):

      if( a(i) ) doSomething();

      if( a.testBit(i) ) doSomething();

RWGBitVec(sz) 
operator&(const RWGBitVec(sz)& v1, const RWGBitVec(sz)& v2);
RWGBitVec(sz) 
operator^(const RWGBitVec(sz)& v1, const RWGBitVec(sz)& v2);
RWGBitVec(sz) 
operator|(const RWGBitVec(sz)& v1, const RWGBitVec(sz)& v2);

Return the logical AND, XOR, and OR, respectively, of vectors v1 and v2.

RWBoolean 
operator==(const RWGBitVec(sz)& v1, const RWGBitVec(sz)& v2) 
           const;

Returns TRUE if each bit of v1 is set to the same value as the corresponding bit in v2. Otherwise, returns FALSE.

RWBoolean 
operator!=(const RWGBitVec(sz)& v1, const RWGBitVec(sz)& v2) 
           const;

Returns FALSE if each bit of v1 is set to the same value as the corresponding bit in v2. Otherwise, returns TRUE.