Big Bits

This class starts very simple. Just an unsigned integer to hold how many bytes the array is managing and a unsigned character pointer that will hold onto a dynamically allocated array of bytes for us.

Now we don't want to leak memory, crash or just be unusable so lets add the constructor, trilogy of evil (destructor, copy constructor, assignment operator), accessors, and mutators.

///////////////////// // Inline functions ///////////////////// public: //Public construction Bits(int Num_Bytes):m_NumBytes(Num_Bytes) { m_Bits = new unsigned char[Num_Bytes]; ZeroMemory(m_Bits,Num_Bytes); } private: //Private Construction //Only used as a helper function for other class methods Bits(unsigned char * Bits, int Num_Bytes):m_NumBytes(Num_Bytes),m_Bits(Bits) {} public: //Assessor unsigned int GetNumBytes(void) { return m_NumBytes; } //Destructor ~Bits(void) { delete [] m_Bits; } //Array access operator unsigned char& operator [](unsigned int x) { return m_Bits[x]; } ////////////////////////// // Function declarations ////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Copy Constructor: // // Purpose: Sets the default information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied Bits(const Bits& _Bits); //////////////////////////////////////////////////////////////////////////////// // Equals Operator: // // Purpose: Sets the information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied Bits& operator=(const Bits& _Bits);

So now lets get into the meat of the code. the operators. Let's to the easy ones first. The AND OR XOR and Negation operators.

These operators are really no different the any other bitwise operation. We just have to do it multiple times.

Header:

CPP

//////////////////////////////////////////////////////////////////////////////// // Bitwise operators: // // Purpose: Return a copy of this structure with the bits modified // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: Bits the copy of this class after being modified //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator &(const Bits& x)const { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes; i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } Bits Bits::operator |(const Bits& x)const { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } Bits Bits::operator ^(const Bits& x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } //////////////////////////////////////////////////////////////////////////////// // negation operator: // // Purpose: Return a copy of this structure with the bits inverted // // Return: Bits the copy of this class after being modified //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator ~()const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i = m_NumBytes-1; i > -1; i--) { temp[i] = ~m_Bits[i]; } return Bits(temp,m_NumBytes); } //////////////////////////////////////////////////////////////////////////////// // Bitwise Equal Operators: // // Purpose: Modify this structure by the bits passed in // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: A reference to this structure //////////////////////////////////////////////////////////////////////////////// Bits& Bits::operator &=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes; i++) m_Bits[i] &= x.m_Bits[i]; return *this; } } Bits& Bits::operator |=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) m_Bits[i] |= x.m_Bits[i]; return *this; } } Bits& Bits::operator ^=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) m_Bits[i] ^= x.m_Bits[i]; return *this; } }

Now to the slightly more challenging section the shift operators. the shift operators are more challenging because we do not want to loose the values of a bit when it shifts off or one byte onto another so it byte one is 10010011 and byte 2 is 10010011 we want their shifted values to be 00100111 and 00100110 not 00100110 and 00100110

Header:

CPP

//////////////////////////////////////////////////////////////////////////////// // Shift operators: // // Purpose: Return a copy of this structure with the bits shifted // // Parameters: unsigned int x: // How many times to shift // // Return: Bits the copy of this class after shifting //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator <<(unsigned int x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } return Bits(temp,m_NumBytes); } Bits Bits::operator >>(unsigned int x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; /how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } return Bits(temp,m_NumBytes); } //////////////////////////////////////////////////////////////////////////////// // Shift Equals operators: // // Purpose: Modify this structure by shifting the bits // // Parameters: unsigned int x: // How many times to shift // // Return: A reference to this structure //////////////////////////////////////////////////////////////////////////////// Bits& Bits::operator <<=(unsigned int x) { if(!x) return *this; //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } //////////////////////////////////////////////////// //Free the memory taken from the old array //assign the member variable to the new array delete [] m_Bits; m_Bits = temp; return *this; } Bits& Bits::operator >>=(unsigned int x) { if(!x) return *this; //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = 0; (unsigned int)i < m_NumBytes; i++) { temp[i] = m_Bits[BigShift + i] >> SmallShift; if(i < (int)m_NumBytes - BigShift) temp[i] |= m_Bits[BigShift4 + i] << SmallShift2; } //////////////////////////////////////////////////// //Free the memory taken from the old array //assign the member variable to the new array delete [] m_Bits; m_Bits = temp; return *this; }

So there we have it, a manual implementation of the bitarray class.

Here is the compiled class.

Header:

//////////////////////////////////////////////////////////////////////////////// // File name: Bits.h // // Purpose: A data structure to simulate a very long sequence of bits // with bitwise functionality // // Related Files: "windows.h" included for the ZeroMemory function // // Author: John O'Leske // // Created: 7/23/07 // // Last Modified: 10/24/07 //////////////////////////////////////////////////////////////////////////////// #pragma once #include "windows.h" //////////////////////////////////////////////////////////////////////////////// // Bits: // // Purpose: A data structure to simulate a very long sequence of bits // with bitwise functionality class Bits { //////////// // Members //////////// private: unsigned int m_NumBytes; unsigned char * m_Bits; ///////////////////// // Inline functions ///////////////////// public: //Public construction Bits(int Num_Bytes):m_NumBytes(Num_Bytes) { m_Bits = new unsigned char[Num_Bytes]; ZeroMemory(m_Bits,Num_Bytes); } private: //Private Construction //Only used as a helper function for other class methods Bits(unsigned char * Bits, int Num_Bytes):m_NumBytes(Num_Bytes),m_Bits(Bits) {} public: //Assessor unsigned int GetNumBytes(void) { return m_NumBytes; } //Destructor ~Bits(void) { delete [] m_Bits; } //Array access operator unsigned char& operator [](unsigned int x) { return m_Bits[x]; } ////////////////////////// // Function declarations ////////////////////////// //////////////////////////////////////////////////////////////////////////////// // Copy Constructor: // // Purpose: Sets the default information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied Bits(const Bits& _Bits); //////////////////////////////////////////////////////////////////////////////// // Equals Operator: // // Purpose: Sets the information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied Bits& operator=(const Bits& _Bits); //////////////////////////////////////////////////////////////////////////////// // Shift operators: // // Purpose: Return a copy of this structure with the bits shifted // // Parameters: unsigned int x: // How many times to shift // // Return: Bits the copy of this class after shifting Bits operator << (unsigned int x) const; Bits operator >> (unsigned int x) const; //////////////////////////////////////////////////////////////////////////////// // Bitwise operators: // // Purpose: Return a copy of this structure with the bits modified // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: Bits the copy of this class after being modified Bits operator & (const Bits& x) const; Bits operator | (const Bits& x) const; Bits operator ^ (const Bits& x) const; //////////////////////////////////////////////////////////////////////////////// // negation operator: // // Purpose: Return a copy of this structure with the bits inverted // // Return: Bits the copy of this class after being modified Bits operator ~ () const; //////////////////////////////////////////////////////////////////////////////// // Shift Equals operators: // // Purpose: Modify this structure by shifting the bits // // Parameters: unsigned int x: // How many times to shift // // Return: A reference to this structure Bits& operator <<= (unsigned int x); Bits& operator >>= (unsigned int x); //////////////////////////////////////////////////////////////////////////////// // Bitwise Equal Operators: // // Purpose: Modify this structure by the bits passed in // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: A reference to this structure Bits& operator &= (const Bits& x); Bits& operator |= (const Bits& x); Bits& operator ^= (const Bits& x); };

CPP

//////////////////////////////////////////////////////////////////////////////// // File name: Bits.cpp // // Purpose: A data structure to simulate a very long sequence of bits // with bitwise functionality // // Related Files: "Bits.h" // "windows.h" included for the ZeroMemory function //////////////////////////////////////////////////////////////////////////////// #include "Bits.h" //////////////////////////////////////////////////////////////////////////////// // Copy Constructor: // // Purpose: Sets the default information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied //////////////////////////////////////////////////////////////////////////////// Bits::Bits(const Bits& _Bits):m_NumBytes(_Bits.m_NumBytes) { m_Bits = new unsigned char[m_NumBytes]; memcpy(m_Bits,_Bits.m_Bits,m_NumBytes); } //////////////////////////////////////////////////////////////////////////////// // Equals Operator: // // Purpose: Sets the information for the structure equal // to the structure passed in // // Parameters: const Bits& _Bits: // The structure to be copied //////////////////////////////////////////////////////////////////////////////// Bits& Bits::operator=(const Bits& _Bits) { if(this != &_Bits) { m_NumBytes = _Bits.m_NumBytes; delete [] m_Bits; m_Bits = new unsigned char[m_NumBytes]; memcpy(m_Bits,_Bits.m_Bits,m_NumBytes); } return *this; } //////////////////////////////////////////////////////////////////////////////// // Shift operators: // // Purpose: Return a copy of this structure with the bits shifted // // Parameters: unsigned int x: // How many times to shift // // Return: Bits the copy of this class after shifting //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator <<(unsigned int x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } return Bits(temp,m_NumBytes); } Bits Bits::operator >>(unsigned int x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; /how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } return Bits(temp,m_NumBytes); } //////////////////////////////////////////////////////////////////////////////// // Bitwise operators: // // Purpose: Return a copy of this structure with the bits modified // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: Bits the copy of this class after being modified //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator &(const Bits& x)const { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes; i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } Bits Bits::operator |(const Bits& x)const { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } Bits Bits::operator ^(const Bits& x)const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = x.m_Bits[i]; return Bits(temp,x.m_NumBytes); } else { //loop though the bytes for(int i=0; (unsigned int)i < m_NumBytes;i++) (unsigned int)i < x.m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = m_Bits[i]; return Bits(temp,m_NumBytes); } } //////////////////////////////////////////////////////////////////////////////// // negation operator: // // Purpose: Return a copy of this structure with the bits inverted // // Return: Bits the copy of this class after being modified //////////////////////////////////////////////////////////////////////////////// Bits Bits::operator ~()const { //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); //loop though the bytes for(int i = m_NumBytes-1; i > -1; i--) { temp[i] = ~m_Bits[i]; } return Bits(temp,m_NumBytes); } //////////////////////////////////////////////////////////////////////////////// // Shift Equals operators: // // Purpose: Modify this structure by shifting the bits // // Parameters: unsigned int x: // How many times to shift // // Return: A reference to this structure //////////////////////////////////////////////////////////////////////////////// Bits& Bits::operator <<=(unsigned int x) { if(!x) return *this; //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = m_NumBytes-1; i > BigShift2; i--) { temp[i] = m_Bits[i-BigShift] << SmallShift; if(i > BigShift) temp[i] |= m_Bits[i-BigShift4] >> SmallShift2; } //////////////////////////////////////////////////// //Free the memory taken from the old array //assign the member variable to the new array delete [] m_Bits; m_Bits = temp; return *this; } Bits& Bits::operator >>=(unsigned int x) { if(!x) return *this; //////////////////////////////////////////////////// //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[m_NumBytes]; ZeroMemory(temp,m_NumBytes); ////////////////////////////////////////////////////// //// Set up variables for the shifting the bytes int BigShift = x/8; //how many whole bytes it will be shifted by int SmallShift = x % 8; //how many bits must be shifted after the whole bytes are shifted int BigShift2 = BigShift-1; //when to stop looping //////////////////////////////////////////////////// // Set up variables for the shifting the overflow int BigShift4 = BigShift + 1; //how many whole bytes was it shifted by int SmallShift2 = 8 - SmallShift; //how big is the overflow //////////////////////////////////////////////////// //Shift each sub for(int i = 0; (unsigned int)i < m_NumBytes; i++) { temp[i] = m_Bits[BigShift + i] >> SmallShift; if(i < (int)m_NumBytes - BigShift) temp[i] |= m_Bits[BigShift4 + i] << SmallShift2; } //////////////////////////////////////////////////// //Free the memory taken from the old array //assign the member variable to the new array delete [] m_Bits; m_Bits = temp; return *this; } //////////////////////////////////////////////////////////////////////////////// // Bitwise Equal Operators: // // Purpose: Modify this structure by the bits passed in // // Parameters: const Bits& x: // The bits used to modify this structure // // Return: A reference to this structure //////////////////////////////////////////////////////////////////////////////// Bits& Bits::operator &=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] & m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes; i++) m_Bits[i] &= x.m_Bits[i]; return *this; } } Bits& Bits::operator |=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] | m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) m_Bits[i] |= x.m_Bits[i]; return *this; } } Bits& Bits::operator ^=(const Bits& x) { // Find which of the two Bits are larger if(x.m_NumBytes > m_NumBytes) { //Create a destination array to contain the large binary number //Set that array's data to zero unsigned char * temp = new unsigned char[x.m_NumBytes]; ZeroMemory(temp,x.m_NumBytes); //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) (unsigned int)i < m_NumBytes ? temp[i] = x.m_Bits[i] ^ m_Bits[i] : temp[i] = x.m_Bits[i]; delete [] m_Bits; m_Bits = temp; m_NumBytes = x.m_NumBytes; return *this; } else { //loop though the bytes for(int i=0; (unsigned int)i < x.m_NumBytes;i++) m_Bits[i] ^= x.m_Bits[i]; return *this; } }