Кто это?

README.md

@@ -1,6 +1,6 @@
 # Методы программирования 2: Множества на основе битовых полей
-
-
+for fun+
+for not fun
 [![Gitter](https://badges.gitter.im/Join%20Chat.svg)][gitter]
 
 <!-- TODO

src/tbitfield.cpp

@@ -8,31 +8,49 @@
 #include <limits>
 #include <iostream>
 #include "tbitfield.h"
+//d
+class Error : private std::exception {};
 
 TBitField::TBitField(size_t len)
 {
-
+    bitLen = len;
+    if (len == 0)
+        memLen = 0;
+    else
+        memLen = 1 + len / (sizeof(uint) * 8);
+    pMem = new uint[memLen];
+    for (int i = 0; i < memLen; i++)
+        pMem[i] = 0;
 }
 
-TBitField::TBitField(const TBitField &bf) // конструктор копирования
+TBitField::TBitField(const TBitField& bf) // конструктор копирования
 {
-
+    bitLen = bf.bitLen;
+    memLen = bf.memLen;
+    pMem = new uint[memLen];
+    for (int i = 0; i < memLen; i++)
+        pMem[i] = bf.pMem[i];
 }
 
 size_t TBitField::getIndex(const size_t n) const  // индекс в pМем для бита n
 {
     return 0;
+    return (n / (sizeof(uint) * 8));
 }
 
 uint TBitField::getMask(const size_t n) const // битовая маска для бита n
 {
     return 0;
+    uint res = 0;
+    res = res | 1 << (n % (sizeof(uint) * 8));
+    return res;
 }
 
 // доступ к битам битового поля
 uint TBitField::getLength() const // получить длину (к-во битов)
 {
     return 0;
+    return bitLen;
 }
 
 size_t TBitField::getNumBytes() const // получить количество байт выделенной памяти
@@ -42,12 +60,27 @@ size_t TBitField::getNumBytes() const // получить количество 
 
 void TBitField::setBit(const size_t n) // установить бит
 {
-
+    if (bitLen < n) {
+        Error a;
+        throw a;
+    }
+    else {
+        size_t position = getIndex(n);
+        pMem[position] = pMem[position] | getMask(n);
+    }
 }
 
 void TBitField::clrBit(const size_t n) // очистить бит
 {
-
+    if ((n < 0) || (bitLen < n)) {
+        Error a;
+        throw a;
+    }
+    else {
+        int position = getIndex(n);
+        elType mask = ~(getMask(n));
+        pMem[position] = pMem[position] & mask;
+    }
 }
 
 bool TBitField::getBit(const size_t n) const // получить значение бита
@@ -56,48 +89,144 @@ bool TBitField::getBit(const size_t n) const // получить значени
 }
 
 // битовые операции
-TBitField& TBitField::operator=(const TBitField &bf) // присваивание
-{
+TBitField& TBitField::operator=(const TBitField& bf) // присваивание
+{
+    if ((n < 0) || (bitLen < n)) {
+        Error a;
+        throw a;
+    }
+    else {
+        int position = getIndex(n);
+        int N = n % (sizeof(elType) * 8);
+        elType a(bitLen);
+        a = getMask(N);
+        if (a & pMem[position])
+            return true;
+        else
+            return false;
+    }
+}
+
+//битовые операции
+TBitField& TBitField::operator=(const TBitField& bf) // присваивание
+{
+    delete[]pMem;
+    bitLen = bf.bitLen;
+    memLen = bf.memLen;
+    pMem = new elType[memLen];
+    for (int i = 0; i < memLen; i++)
+        pMem[i] = bf.pMem[i];
     return *this;
 }
 
-bool TBitField::operator==(const TBitField &bf) const // сравнение
+bool TBitField::operator==(const TBitField& bf) const // сравнение
 {
     return true;
 }
 
-bool TBitField::operator!=(const TBitField &bf) const // сравнение
+bool TBitField::operator!=(const TBitField& bf) const // сравнение
 {
     return false;
+    if (bitLen == bf.bitLen && memLen == bf.memLen) {
+        for (int i = 0; i < memLen; i++)
+            if (pMem[i] != bf.pMem[i])
+                return false;
+        return true;
+    }
+    else return false;
 }
 
-TBitField TBitField::operator|(const TBitField &bf) // операция "или"
-{
-    return TBitField(1);
-}
-
-TBitField TBitField::operator&(const TBitField &bf) // операция "и"
+TBitField TBitField::operator|(const TBitField& bf) // операция "или"
 {
     return TBitField(1);
+    if (*this == bf)
+        return false;
+    return true;
 }
 
-TBitField TBitField::operator~() // отрицание
+TBitField TBitField::operator&(const TBitField& bf) // операция "и"
 {
     return TBitField(1);
-}
-
-TBitField::~TBitField()
-{
-
-}
-
-// ввод/вывод
-std::istream &operator>>(std::istream &istr, TBitField &bf) // ввод
-{
-    return istr;
-}
-
-std::ostream &operator<<(std::ostream &ostr, const TBitField &bf) // вывод
-{
-    return ostr;
-}
+    TBitField TBitField::operator|(const TBitField & bf) // операция "или"
+    {
+        if (bitLen >= bf.bitLen) {
+            TBitField res(bitLen);
+            for (int i = 0; i < bf.bitLen; i++)
+                if (bf.getBit(i) == 1 || this->getBit(i) == 1)
+                    res.setBit(i);
+            if (bitLen > bf.bitLen)
+                for (int i = bf.bitLen; i < bitLen; i++)
+                    if (this->getBit(i) == 1)
+                        res.setBit(i);
+            return res;
+        }
+        else {
+            TBitField res(bf.bitLen);
+            for (int i = 0; i < bitLen; i++)
+                if (bf.getBit(i) == 1 || this->getBit(i) == 1)
+                    res.setBit(i);
+            for (int i = bitLen; i < bf.bitLen; i++)
+                if (bf.getBit(i) == 1)
+                    res.setBit(i);
+            return res;
+        }
+    }
+
+    TBitField TBitField::operator&(const TBitField & bf) // операция "и"
+    {
+        if (bitLen == bf.bitLen) {
+            TBitField res(bitLen);
+            for (int i = 0; i < bitLen; i++)
+                if (bf.getBit(i) && getBit(i))
+                    res.setBit(i);
+            return res;
+        }
+        else {
+            int max_bitLen, min_bitLen;
+            if (bitLen < bf.bitLen) {
+                max_bitLen = bf.bitLen;
+                min_bitLen = bitLen;
+            }
+            else {
+                max_bitLen = bitLen;
+                min_bitLen = bf.bitLen;
+            }
+            TBitField res(max_bitLen);
+            for (int i = 0; i < min_bitLen; i++)
+                if (bf.getBit(i) && getBit(i))
+                    res.setBit(i);
+            return res;
+        }
+    }
+
+    TBitField TBitField::operator~() // отрицание
+    {
+        return TBitField(1);
+        TBitField res(bitLen);
+        for (int i = 0; i < memLen - 1; i++)
+            res.pMem[i] = ~pMem[i];
+        for (int i = sizeof(elType) * 8 * (memLen - 1); i < bitLen; i++)
+            if (getBit(i) == 0)
+                res.setBit(i);
+        return res;
+    }
+
+    TBitField::~TBitField()
+    {
+        delete[]pMem;
+    }
+
+    // ввод/вывод
+    std::istream& operator>>(std::istream & istr, TBitField & bf) // ввод
+    {
+        return istr;
+    }
+
+    std::ostream& operator<<(std::ostream & ostr, const TBitField & bf) // вывод
+    {
+        for (int i = 0; i < bf.bitLen; i++)
+            ostr << bf.getBit(i);
+        ostr << std::endl;
+        ostr << bf.pMem[bf.bitLen - 1];
+        return ostr;
+    }

src/tset.cpp

@@ -9,63 +9,97 @@
 #include "tbitfield.h"
 #include "tset.h"
 
-TSet::TSet(size_t mp) : bitField(1) {}
+
+TSet::TSet(size_t mp) : bitField(1) {
+    maxPower = mp;
+    bitField = TBitField(mp);
+}
 
 // конструктор копирования
-TSet::TSet(const TSet &s) : bitField(s.bitField) {}
+TSet::TSet(const TSet &s) : bitField(s.bitField) {
+    maxPower = s.maxPower;
+    bitField = s.bitField;
+}
 
 // конструктор преобразования типа
-TSet::TSet(const TBitField &bf) : bitField(bf) {}
+TSet::TSet(const TBitField &bf) : bitField(bf) {
+    maxPower = bf.getLength();
+    bitField = bf;
+}
 
 TSet::operator TBitField()
 {
     return TBitField(1);
+    BitField res(maxPower);
+    res = this->bitField;
+    return res;
 }
 
 size_t TSet::getMaxPower() const // получить макс. к-во эл-тов
 {
     return 0;
+    return maxPower
 }
 
 bool TSet::isMember(const uint elem) const // элемент множества?
 {
+    if (bitField.getBit(elem))
+        return true;
     return false;
 }
 
 void TSet::insElem(const uint elem) // включение элемента множества
 {
-
+    bitField.setBit(elem);
 }
 
 void TSet::delElem(const uint elem) // исключение элемента множества
 {
-
+    bitField.clrBit(elem);
 }
 
 // теоретико-множественные операции
 TSet& TSet::operator=(const TSet &s) // присваивание
 {
+    maxPower = s.maxPower;
+    bitField = s.bitField;
     return *this;
 }
 
 bool TSet::operator==(const TSet &s) const // сравнение
 {
     return false;
+    if (maxPower == s.maxPower && bitField == s.bitField)
+        return true;
+    else return false;
 }
 
 bool TSet::operator!=(const TSet &s) const // сравнение
 {
     return true;
+    if (*this == s)
+        return false;
+    else return true;
 }
 
 TSet TSet::operator+(const TSet &s) // объединение
 {
     return TSet(1);
+    int res_mp;
+    if (maxPower >= s.maxPower)
+        res_mp = maxPower;
+    else
+        res_mp = s.maxPower;
+    TSet res(res_mp);
+    res.bitField = bitField | s.bitField;
+    return res;
 }
 
 TSet TSet::operator+(const uint elem) // объединение с элементом
 {
     return TSet(1);
+    bitField.setBit(elem);
+    return *this;
 }
 
 TSet TSet::operator-(const uint elem) // разность с элементом
@@ -76,11 +110,22 @@ TSet TSet::operator-(const uint elem) // разность с элементом
 TSet TSet::operator*(const TSet &s) // пересечение
 {
     return TSet(1);
+    int res_mp;
+    if (maxPower >= s.maxPower)
+        res_mp = maxPower;
+    else
+        res_mp = s.maxPower;
+    TSet res(res_mp);
+    res.bitField = bitField & s.bitField;
+    return res;
 }
 
 TSet TSet::operator~() // дополнение
 {
     return TSet(1);
+    TSet res(maxPower);
+    res.bitField = ~(bitField);
+    return res;
 }
 
 // перегрузка ввода/вывода