Кротов Роман Битовые поля

src/tbitfield.cpp

@@ -9,92 +9,185 @@
 
 #define BITS_IN_ONE_MEM (sizeof(TELEM) * 8)
 
-TBitField::TBitField(int len)
+TBitField::TBitField(int len) : BitLen(len)
 {
-
+	if (len < 0) 
+	{
+		throw std::runtime_error ("Error len");
+	}
+	else
+	{
+		int size = (len + 31)/32;
+		pMem = new TELEM[size];
+		memset(pMem, 0, sizeof(TELEM) * size);
+	}
 }
 
-TBitField::TBitField(const TBitField& bf) // конструктор копирования
+TBitField::TBitField(const TBitField& bf) 
 {
+	BitLen = bf.BitLen;
+	MemLen = (bf.BitLen + BITS_IN_ONE_MEM - 1) / BITS_IN_ONE_MEM;
+	pMem = new TELEM[MemLen];
+	if (!pMem)
+	{
+		throw std::bad_alloc();
+	}
+	memcpy(pMem, bf.pMem, sizeof(TELEM) * MemLen);
 }
 
-TBitField::~TBitField()
+TBitField::~TBitField() // деструктор
 {
+	delete[] pMem; 
+	pMem = nullptr;
 }
 
 int TBitField::GetMemIndex(const int n) const // индекс Мем для бита n
 {
- return 0;
+	if (n < 0 || n >= BitLen)
+	{
+		throw std::out_of_range("Индекс вне диапозона");
+	}
+	return n / (sizeof(TELEM) * 8);
 }
 
 TELEM TBitField::GetMemMask(const int n) const // битовая маска для бита n
 {
-
-	return 0;
+	return 1 << (n % BITS_IN_ONE_MEM);
 }
 
 // доступ к битам битового поля
 
 int TBitField::GetLength(void) const // получить длину (к-во битов)
 {
-	return 0;
+	return BitLen;
 }
 
 void TBitField::SetBit(const int n) // установить бит
 {
-	if ((n < 0) || (n > BitLen))
-		throw 2;
+	int memIndex = GetMemIndex(n);
+	TELEM mask = GetMemMask(n);
+	pMem[memIndex] |= mask;
 }
 
 void TBitField::ClrBit(const int n) // очистить бит
 {
+	int memIndex = GetMemIndex(n);
+	TELEM mask = GetMemMask(n);
+	pMem[memIndex] &= ~mask;
 }
 
 int TBitField::GetBit(const int n) const // получить значение бита
 {
-	return 0;
+	int memIndex = GetMemIndex(n);
+	TELEM mask = GetMemMask(n);
+	return (pMem[memIndex] & mask) != 0;
 }
 
 // битовые операции
 
 TBitField& TBitField::operator=(const TBitField & bf) // присваивание
 {
+	if (this == &bf) return *this;  
+	BitLen = bf.BitLen;
+	MemLen = (BitLen + BITS_IN_ONE_MEM - 1) / BITS_IN_ONE_MEM;
+	TELEM* newMem = new TELEM[MemLen];
+	if (!newMem) 
+	{
+		throw std::bad_alloc();
+	}
+	memcpy(newMem, bf.pMem, sizeof(TELEM) * MemLen);
+	delete[] pMem;
+	pMem = newMem;
 	return *this;
 }
 
 int TBitField::operator==(const TBitField & bf) const // сравнение
 {
-	return 0;
+	if (BitLen != bf.BitLen)
+		return false;
+	for (int i = 0; i < MemLen; ++i)
+	{
+		if (pMem[i] != bf.pMem[i])
+			return false;
+	}
+	return true;
 }
 
 int TBitField::operator!=(const TBitField & bf) const // сравнение
 {
-	return 0;
+	if (BitLen != bf.BitLen) return 1;  
+	return memcmp(pMem, bf.pMem, sizeof(TELEM) * MemLen) != 0;
 }
 
-TBitField TBitField::operator|(const TBitField & bf) // операция "или"
+TBitField TBitField::operator|(const TBitField& bf)
 {
-	return TBitField(0);
+	int maxLen = std::max(BitLen, bf.BitLen);  
+	TBitField result(maxLen);
+	for (int i = 0; i < MemLen; ++i) {
+		if (i < bf.MemLen) {
+			result.pMem[i] = pMem[i] | bf.pMem[i];  
+		}
+		else {
+			result.pMem[i] = pMem[i];  
+		}
+	}
+	if (bf.MemLen > MemLen) {
+		for (int i = MemLen; i < bf.MemLen; ++i) {
+			result.pMem[i] = bf.pMem[i];
+		}
+	}
+	return result;
 }
 
-TBitField TBitField::operator&(const TBitField & bf) // операция "и"
+TBitField TBitField::operator&(const TBitField& bf)
 {
-	return TBitField(0);
+	int maxLen = std::max(BitLen, bf.BitLen);  
+	TBitField result(maxLen);
+
+	for (int i = 0; i < MemLen; ++i) {
+		if (i < bf.MemLen) {
+			result.pMem[i] = pMem[i] & bf.pMem[i]; 
+		}
+	}
+
+	return result;
 }
 
+
 TBitField TBitField::operator~(void) // отрицание
 {
-  return TBitField(0);
+	TBitField result(BitLen);
+	for (int i = 0; i < MemLen; ++i)
+	{
+		result.pMem[i] = ~pMem[i];
+	}
+	return result;
 }
 
 // ввод/вывод
 
-istream& operator>>(istream & istr, TBitField & bf) // ввод
+istream& operator>>(istream& istr, TBitField& bf)
 {
-  return istr;
+	for (int i = 0; i < bf.BitLen; ++i)
+	{
+		char bit;
+		istr >> bit;
+		if (bit == '1')
+			bf.SetBit(i);
+		else if (bit == '0')
+			bf.ClrBit(i);
+		else
+			throw std::invalid_argument("Invalid bit input");
+	}
+	return istr;
 }
 
-ostream& operator<<(ostream & ostr, const TBitField & bf) // вывод
+ostream& operator<<(ostream& ostr, const TBitField& bf)
 {
+	for (int i = 0; i < bf.BitLen; ++i)
+	{
+		ostr << bf.GetBit(i);
+	}
 	return ostr;
 }
+

src/tset.cpp

@@ -7,18 +7,17 @@
 
 #include "tset.h"
 
-TSet::TSet(int mp) : BitField(mp)
+TSet::TSet(int mp) : MaxPower(mp), BitField(mp)
 {
-
 }
 
 // конструктор копирования
-TSet::TSet(const TSet& s) : BitField(0)
+TSet::TSet(const TSet& s) : MaxPower(s.MaxPower), BitField(s.BitField)
 {
 }
 
 // конструктор преобразования типа
-TSet::TSet(const TBitField& bf) : BitField(0)
+TSet::TSet(const TBitField& bf) : MaxPower(bf.GetLength()), BitField(bf)
 {
 }
 
@@ -34,68 +33,133 @@ int TSet::GetMaxPower(void) const // получить макс. к-во эл-т
 
 int TSet::IsMember(const int Elem) const // элемент множества?
 {
-	return 0;
+    if (Elem >= 0 && Elem < MaxPower)
+    {
+        return BitField.GetBit(Elem); // Возвращаем значение бита
+    }
+    else
+    {
+        throw std::out_of_range("Element out of range");
+    }
 }
 
 void TSet::InsElem(const int Elem) // включение элемента множества
 {
+    if (Elem >= 0 && Elem < MaxPower)
+    {
+        BitField.SetBit(Elem); // Устанавливаем бит для данного элемента
+    }
+    else
+    {
+        throw std::out_of_range("Element out of range");
+    }
 }
 
-void TSet::DelElem(const int Elem) // исключение элемента множества
+void TSet::DelElem(const int Elem)
 {
+    if (Elem >= 0 && Elem < MaxPower)
+    {
+        BitField.ClrBit(Elem); // Очищаем бит для данного элемента
+    }
+    else
+    {
+        throw std::out_of_range("Element out of range");
+    }
 }
 
 // теоретико-множественные операции
 
 TSet& TSet::operator=(const TSet& s) // присваивание
 {
-	return *this;
+    if (this == &s) return *this; // Защита от самоприсваивания
+    MaxPower = s.MaxPower;
+    BitField = s.BitField; // Копируем битовое поле
+    return *this;
 }
 
 int TSet::operator==(const TSet& s) const // сравнение
 {
-	return 0;
+    return BitField == s.BitField;
 }
 
 int TSet::operator!=(const TSet& s) const // сравнение
 {
-  return 0;
+    return BitField != s.BitField;
 }
 
-TSet TSet::operator+(const TSet& s) // объединение
+TSet TSet::operator+(const TSet& s)
 {
-  return TSet(0);
+    int newSize = std::max(MaxPower, s.MaxPower);  // Вычисляем максимальный размер
+    TSet result(newSize); // Создаем множество с этим размером
+    result.BitField = BitField | s.BitField; // Выполняем объединение
+    return result;
 }
 
 TSet TSet::operator+(const int Elem) // объединение с элементом
 {
-
-  return TSet(0);
+    if (Elem < 0 || Elem >= MaxPower) {
+        throw std::out_of_range("Element out of range");
+    }
+    TSet result(*this);  // Создаем копию множества
+    result.InsElem(Elem);  // Включаем элемент
+    return result;
 }
 
 TSet TSet::operator-(const int Elem) // разность с элементом
 {
-  return TSet(0);
+    if (Elem < 0 || Elem >= MaxPower) {
+        throw std::out_of_range("Element out of range");
+    }
+    TSet result(*this);  // Создаем копию множества
+    result.DelElem(Elem);  // Удаляем элемент
+    return result;
 }
 
-TSet TSet::operator*(const TSet& s) // пересечение
+TSet TSet::operator*(const TSet& s)
 {
-  return TSet(0);
+    int newSize = std::max(MaxPower, s.MaxPower); // Вычисляем максимальный размер
+    TSet result(newSize); // Создаем множество с этим размером
+    result.BitField = BitField & s.BitField; // Выполняем пересечение
+    return result;
 }
 
+
 TSet TSet::operator~(void) // дополнение
 {
-  return TSet(0);
+    TSet result(MaxPower);
+    result.BitField = ~BitField;  // Инвертируем битовое поле
+    return result;
 }
 
 // перегрузка ввода/вывода
 
 istream& operator>>(istream& istr, TSet& s) // ввод
 {
-  return istr;
+    for (int i = 0; i < s.MaxPower; ++i)
+    {
+        int bit;
+        istr >> bit;
+        if (bit == 1)
+        {
+            s.InsElem(i); // Включаем элемент
+        }
+        else if (bit == 0)
+        {
+            s.DelElem(i); // Удаляем элемент
+        }
+        else
+        {
+            throw std::invalid_argument("Invalid input");
+        }
+    }
+    return istr;
 }
 
 ostream& operator<<(ostream& ostr, const TSet& s) // вывод
 {
+	for (int i = 0; i < s.MaxPower; ++i)
+	{
+		ostr << s.IsMember(i); // Печатаем элемент (1 или 0)
+	}
 	return ostr;
 }