.

src/tbitfield.cpp

@@ -9,92 +9,202 @@
 
 #define BITS_IN_ONE_MEM (sizeof(TELEM) * 8)
 
-TBitField::TBitField(int len)
+TBitField::TBitField(int len) : BitLen(len)
 {
-
+	if (len < 0)
+		throw len;
+	else
+	{
+		MemLen = (len + 15) >> 4;
+		pMem = new TELEM[MemLen];
+		if (pMem != NULL)
+			for (int i = 0; i < MemLen; i++) pMem[i] = 0;
+	}
 }
 
 TBitField::TBitField(const TBitField& bf) // конструктор копирования
 {
+	MemLen = bf.MemLen;
+	BitLen = bf.BitLen;
+	pMem = new TELEM[MemLen];
+	for (int i = 0; i < MemLen; i++)
+		pMem[i] = bf.pMem[i];
 }
 
 TBitField::~TBitField()
 {
+	delete[]pMem;
 }
 
 int TBitField::GetMemIndex(const int n) const // индекс Мем для бита n
-{
- return 0;
+{// преобразовать к int и разделить на 16
+	if ((n < 0) || (n > BitLen))
+		throw n;
+	else
+	return n >> 4; 
+
 }
 
 TELEM TBitField::GetMemMask(const int n) const // битовая маска для бита n
 {
-
-	return 0;
+	if ((n < 0) || (n > BitLen))
+		throw n;
+	else
+	{
+		return 1 << (n & 15);
+	}
 }
 
 // доступ к битам битового поля
 
 int TBitField::GetLength(void) const // получить длину (к-во битов)
 {
-	return 0;
+	return BitLen;
 }
 
 void TBitField::SetBit(const int n) // установить бит
 {
 	if ((n < 0) || (n > BitLen))
-		throw 2;
+		throw n;
+	else
+		pMem[GetMemIndex(n)] |= GetMemMask(n);
 }
-
 void TBitField::ClrBit(const int n) // очистить бит
 {
+
+	if ((n < 0) || (n > BitLen))
+		throw n;
+	else
+		pMem[GetMemIndex(n)] &= ~GetMemMask(n);
 }
 
 int TBitField::GetBit(const int n) const // получить значение бита
 {
-	return 0;
+	if ((n < 0) || (n > BitLen))
+		throw n;
+	else
+	{
+		int result = (GetMemMask(n) & pMem[GetMemIndex(n)]);
+		if (result == 0)
+			return(0);
+		else
+			return(1);
+	}
 }
 
 // битовые операции
 
 TBitField& TBitField::operator=(const TBitField & bf) // присваивание
 {
+	if (this != &bf)
+	{
+		delete []pMem;
+		BitLen = bf.BitLen;
+		MemLen = bf.MemLen;
+		pMem = new TELEM[MemLen];
+		for (int i = 0; i < MemLen; i++)
+			pMem[i] = bf.pMem[i];
+	}
 	return *this;
+
 }
 
 int TBitField::operator==(const TBitField & bf) const // сравнение
 {
-	return 0;
+	if (BitLen != bf.BitLen)
+	  return 0;
+  else
+  {
+	  for (int i = 0; i < BitLen; i++)
+		  if (GetBit(i) != bf.GetBit(i))
+			  return 0;
+	  return 1;
+  }
 }
 
 int TBitField::operator!=(const TBitField & bf) const // сравнение
 {
-	return 0;
+	if (BitLen != bf.BitLen)
+		return 1;
+	else
+	{
+		for (int i = 0; i < BitLen; i++)
+			if (GetBit(i) != bf.GetBit(i))
+				return 1;
+		return 0;
+	}
 }
 
 TBitField TBitField::operator|(const TBitField & bf) // операция "или"
 {
-	return TBitField(0);
+	int i;
+	if (bf.BitLen > BitLen) BitLen = bf.BitLen;
+	TBitField tmp(BitLen);
+	for (i = 0; i < MemLen; i++) tmp.pMem[i] = pMem[i];
+	for (i = 0; i < bf.MemLen; i++) tmp.pMem[i] |= bf.pMem[i];
+	return tmp;
 }
 
-TBitField TBitField::operator&(const TBitField & bf) // операция "и"
+TBitField TBitField::operator&(const TBitField& bf) // операция "и"
 {
-	return TBitField(0);
+	if (BitLen == bf.BitLen)
+	{
+		int i;
+
+		TBitField tmp(BitLen);
+
+		for (i = 0; i < MemLen; i++) tmp.pMem[i] = pMem[i];
+
+		for (i = 0; i < bf.MemLen; i++) tmp.pMem[i] &= bf.pMem[i];
+
+		return tmp;
+	}
+	else
+	{
+		if (BitLen < bf.BitLen) BitLen = bf.BitLen;
+		TBitField tmp(BitLen);
+		for (int i = 0; i < bf.BitLen; i++)
+		{
+			int tmpval = (GetBit(i) && bf.GetBit(i));
+			if (tmpval == 0)
+				tmp.ClrBit(i);
+			else
+				tmp.SetBit(i);
+		}
+		for (int i = bf.BitLen; i < BitLen; i++)
+			tmp.ClrBit(i);
+		return tmp;
+	}
+
 }
 
-TBitField TBitField::operator~(void) // отрицание
-{
-  return TBitField(0);
+TBitField TBitField::operator~(void) { // отрицание
+	TBitField tmp = (*this);
+	for (size_t i = 0; i < BitLen; i++) {
+		if (tmp.GetBit(i))
+			tmp.ClrBit(i);
+		else
+			tmp.SetBit(i);
+	}
+	return tmp;
 }
 
 // ввод/вывод
 
 istream& operator>>(istream & istr, TBitField & bf) // ввод
 {
-  return istr;
+	int i = 0;
+	while ((i >= 0) && (i < bf.BitLen))
+	{
+		bf.SetBit(i);
+		istr >> i;
+	}
+	return istr;
 }
 
 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,19 +7,22 @@
 
 #include "tset.h"
 
-TSet::TSet(int mp) : BitField(mp)
+TSet::TSet(int mp = 100) : BitField(mp), MaxPower(mp) 
 {
-
 }
 
 // конструктор копирования
 TSet::TSet(const TSet& s) : BitField(0)
 {
+	MaxPower = s.MaxPower;
+	BitField = s.BitField;
 }
 
 // конструктор преобразования типа
-TSet::TSet(const TBitField& bf) : BitField(0)
+TSet::TSet(const TBitField& bf) : BitField(bf.GetLength())
 {
+	BitField = bf;
+	MaxPower = bf.GetLength();
 }
 
 TSet::operator TBitField()
@@ -34,68 +37,87 @@ int TSet::GetMaxPower(void) const // получить макс. к-во эл-т
 
 int TSet::IsMember(const int Elem) const // элемент множества?
 {
-	return 0;
+	return BitField.GetBit(Elem);
 }
 
 void TSet::InsElem(const int Elem) // включение элемента множества
 {
+	BitField.SetBit(Elem);
 }
 
 void TSet::DelElem(const int Elem) // исключение элемента множества
 {
+	BitField.ClrBit(Elem);
 }
 
 // теоретико-множественные операции
 
 TSet& TSet::operator=(const TSet& s) // присваивание
 {
+	BitField = s.BitField;
+	MaxPower = s.MaxPower;
 	return *this;
 }
 
 int TSet::operator==(const TSet& s) const // сравнение
 {
-	return 0;
+	return (MaxPower == s.MaxPower) && (BitField == s.BitField);
 }
 
 int TSet::operator!=(const TSet& s) const // сравнение
 {
-  return 0;
+  return ((MaxPower != s.MaxPower) || (BitField != s.BitField));
 }
 
 TSet TSet::operator+(const TSet& s) // объединение
 {
-  return TSet(0);
+	TSet tmp(BitField | s.BitField);
+	return tmp;
 }
 
 TSet TSet::operator+(const int Elem) // объединение с элементом
 {
-
-  return TSet(0);
+	TSet tmp(BitField);
+	tmp.InsElem(Elem);
+	return tmp;
 }
 
 TSet TSet::operator-(const int Elem) // разность с элементом
 {
-  return TSet(0);
+	TSet tmp(*this);
+	tmp.BitField.ClrBit(Elem);
+	return tmp;
 }
 
 TSet TSet::operator*(const TSet& s) // пересечение
 {
-  return TSet(0);
+	TSet tmp(BitField & s.BitField);
+  return tmp;
 }
 
 TSet TSet::operator~(void) // дополнение
 {
-  return TSet(0);
+	TSet tmp(~BitField);
+  return tmp;
 }
 
 // перегрузка ввода/вывода
 
 istream& operator>>(istream& istr, TSet& s) // ввод
 {
+	int i = 0;
+	while ((i >= 0) && (i < s.MaxPower))
+	{
+		s.InsElem(i);
+		istr >> i;
+	}
   return istr;
 }
 
 ostream& operator<<(ostream& ostr, const TSet& s) // вывод
 {
+	for (int i = 0; i < s.MaxPower; i++)
+		if (s.BitField.GetBit(i))
+			ostr << i;
 	return ostr;
 }