面向对象程序设计第一次实验课——位运算封装

最新推荐文章于 2022-02-01 23:12:44 发布
最新推荐文章于 2022-02-01 23:12:44 发布
阅读量805 收藏 1
点赞数 2
分类专栏： C++ 文章标签： 位运算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jlu_nnbs/article/details/70833509
版权

题目的大意是用一个类封装位运算，并通过位运算实现四则运算。我一下子就想起了bitset，但是bitset并不支持四则运算。后来想想也许叫大整数类比较合适吧。

当然还是有很多问题的，有些问题是写完了才发现的，当时发着高烧，一边写一边debug，好不容易赶到deadline前，交过之后也没有改的动力了……

首先是该用友元实现的二元关系的运算符全写在类内了，写之前应该看看书的。其次是没有实现下标运算符的重载，这个要用到设计模式中的代理模式，同样是没来得及写，这里有篇blog里面实现了：
http://blog.csdn.net/fastsort/article/details/8922923

一些其他问题写在了实验报告中。

bit.h

#pragma once
#include <string>
#include <cstring>
#include <cmath>
#define BLOCK (len_ / (8 * sizeof(size_t)) + (len_ % (sizeof(size_t) * 8)? 1: 0))
#define BLOCKBIT (8 * sizeof(size_t)) 
using namespace std;
template <size_t len_> //len_ is the number of bit(s) 
class myBitset {
    friend ostream& operator<< (ostream &out, const myBitset<len_>& bs) 
    {
        // stored reversely, so output reversely
        for (size_t i = 0; i < len_; i ++) {
            if (bs.isTrue(len_ - i - 1)) out << "1";
            else out << "0";
//          printf("%d ",i);
        }
        return out;
    }
    public:
        myBitset() : block_(BLOCK) 
        {
            num_ = new size_t[block_];  
            memset(num_, 0, block_ * sizeof(size_t));
//          printf("%d %d %d\n", block_, sizeof(size_t), block_ * sizeof(size_t));
//          for (int i = 0; i < block_; i ++) num_[i] = 0;
//          cout << *this << endl;      
        }

        myBitset(const myBitset& bs);
//invert signed number to myBitset, and avoid ambiguous calling for overloaded functions
        myBitset(signed int num);
        myBitset(unsigned int num);
        myBitset(signed long);
        myBitset(unsigned long);
//      myBitset(signed long long);
//      myBitset(unsigned long long);
        myBitset(signed __int64 num);
        myBitset(unsigned __int64 num);
        myBitset(const string& s);
        ~myBitset();

        myBitset& operator= (const myBitset& bs);
        myBitset operator& (const myBitset& bs) const; 
        myBitset operator| (const myBitset& bs) const;
        myBitset operator~ (void) const;
        myBitset operator^ (const myBitset& bs) const;
    //  BOTH TWO BELOW ARE LOGICAL SHIFT! BE CAREFUL !
        myBitset operator<< (size_t shift) const;
        myBitset operator>> (size_t shift) const;
        myBitset& operator&= (const myBitset& bs);
        myBitset& operator|= (const myBitset& bs);
        myBitset& operator^= (const myBitset& bs);
        myBitset& operator<<= (size_t shift);
        myBitset& operator>>= (size_t shift);

        myBitset& operator++ (void);
        myBitset& operator-- (void);
        myBitset operator++ (int dummy);
        myBitset operator-- (int dummy);
    //  in operator+= we need local variables of myBitset, so argument is not reference
        myBitset& operator+= (myBitset bs);
        myBitset& operator-= (const myBitset& bs);
        myBitset operator+ (const myBitset& bs) const;
        myBitset operator- (const myBitset& bs) const;
        myBitset operator+ (void) const;
        myBitset operator- (void) const;

        myBitset operator* (const myBitset& bs) const;
        myBitset operator/ (const myBitset& bs) const;
//      myBitset operator% (const myBitset& bs) const;
        myBitset& operator*= (myBitset bs);
        myBitset& operator/= (myBitset bs);

        bool operator> (const myBitset& bs) const;
        bool operator>= (const myBitset& bs) const;
        bool operator< (const myBitset& bs) const;
        bool operator<= (const myBitset& bs) const;
        bool operator== (const myBitset& bs) const;
        bool operator!= (const myBitset& bs) const;

        explicit operator bool(void) const;
        void flip();// flip all bits
        void set(size_t index);
        void reset(size_t index);
        bool isTrue(size_t index) const;
        size_t getBlock(void) { return block_;}
        size_t getLen(void) { return len_;}
    private:
        size_t* num_;   //pointer to where the bits stored
        const size_t block_;  //the size of the array   
};

template <size_t len_> myBitset<len_>::myBitset(const myBitset<len_>& bs) : 
    block_(bs.block_)
{
    num_ = new size_t[block_];
    for (size_t i = 0; i < bs.block_; i ++) 
        num_[i] = bs.num_[i];
}
// lower bit is stored in the smaller index
template <size_t len_> myBitset<len_>::myBitset(unsigned __int64 num) : myBitset()
{
    size_t p = 0;
//  printf("%llu\n",num);
    while (num && p < len_) {
        if (num & 1) {
            set(p);
//          printf("%d\n",p);
        }
        ++ p;
        num >>= 1;
    }
    // size_t is an unsigned type !!
}
//template <size_t len_> myBitset<len_>::myBitset(unsigned long long num) : 
//  myBitset(unsigned __int64(num)) {}
template <size_t len_> myBitset<len_>::myBitset(unsigned long num) : 
    myBitset(static_cast<unsigned __int64>(num)) {}
template <size_t len_> myBitset<len_>::myBitset(unsigned int num) : 
    myBitset(static_cast<unsigned __int64>(num)) {}

template <size_t len_> myBitset<len_>::myBitset(signed __int64 num) : 
    myBitset(static_cast<unsigned __int64>(abs(num)))
{
    if (num < 0) {
        flip();
        ++ (*this);
    }
}
//template <size_t len_> myBitset<len_>::myBitset(signed long long num) : 
//  myBitset(signed __int64(num)) {}
template <size_t len_> myBitset<len_>::myBitset(signed long num) : 
    myBitset(static_cast<signed __int64>(num)) {}
template <size_t len_> myBitset<len_>::myBitset(signed int num) : 
    myBitset(static_cast<signed __int64>(num)) {}

template <size_t len_> myBitset<len_>::myBitset(const string& s) : myBitset()
{
    for (size_t i = 0; i < s.size(); i ++) {
        if (s[i] != '0') {
            set(s.size() - i - 1);
        }
    }
}
template <size_t len_> myBitset<len_>::~myBitset()
{
    delete []num_;
}

template <size_t len_> inline void myBitset<len_>::set(size_t index)
{
    // 1不加强制类型转换为什么会出现循环左移…… 
    num_[index / BLOCKBIT] |= (size_t(1) << (index % BLOCKBIT));
//  printf("%d %d %d\n",index, index / BLOCKBIT, index % BLOCKBIT);
    return ;
}

template <size_t len_> inline void myBitset<len_>::reset(size_t index)
{
    num_[index / BLOCKBIT] &= ~(size_t(1) << (index % BLOCKBIT));
    return ;
}

template <size_t len_> inline bool myBitset<len_>::isTrue(size_t index) const
{
//  if (num_[index / BLOCKBIT] & (size_t(1) << (index % BLOCKBIT))) printf(" %d %d %d\n",index, index / BLOCKBIT,index %BLOCKBIT);
//  printf("%llu\n",1 << (index % BLOCKBIT));
    return num_[index / BLOCKBIT] & (size_t(1) << (index % BLOCKBIT));
}

template <size_t len_> inline void myBitset<len_>::flip(void)
{
    for (size_t i = 0; i < block_; i ++) {
        num_[i] = ~num_[i];
    }
    return ;
}
template <size_t len_> myBitset<len_>& myBitset<len_>::operator= (const myBitset& bs)
{
    if (this != &bs) {
        for (size_t i = 0; i < block_; i ++)
            num_[i] = bs.num_[i];
    }
}
template <size_t len_> myBitset<len_> myBitset<len_>::operator&(const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs &= bs;
    return tbs;
}
template <size_t len_> myBitset<len_> myBitset<len_>::operator|(const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs |= bs;
    return tbs;
}

template <size_t len_> myBitset<len_> myBitset<len_>::operator~(void) const
{
    myBitset<len_> tbs(*this);
    tbs.flip();
    return tbs;
}

template <size_t len_> myBitset<len_> myBitset<len_>::operator^(const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs ^= bs;
    return tbs;
}

template <size_t len_> myBitset<len_> myBitset<len_>::operator<<(size_t shift) const
{
    myBitset<len_> tbs(*this);
    tbs <<= shift;
    return tbs;
}

template <size_t len_> myBitset<len_> myBitset<len_>::operator>>(size_t shift) const
{
    myBitset<len_> tbs(*this);
    tbs >>= shift;
    return tbs;
}

template<size_t len_> myBitset<len_>& myBitset<len_>::operator&= (const myBitset& bs)
{
    for (size_t i = 0; i < block_; i ++) {
        num_[i] &= bs.num_[i];
    }
    return *this;
}

template<size_t len_> myBitset<len_>& myBitset<len_>::operator|= (const myBitset& bs)
{
    for (size_t i = 0; i < block_; i ++) {
        num_[i] |= bs.num_[i];
    }
    return *this;
}

template<size_t len_> myBitset<len_>& myBitset<len_>::operator^= (const myBitset& bs)
{
    for (size_t i = 0; i < block_; i ++) {
        num_[i] ^= bs.num_[i];
    }
    return *this;
}

template<size_t len_> myBitset<len_>& myBitset<len_>::operator<<= (size_t shift)
{
    if (shift == 0) return *this;
    if (shift >= len_) {
        memset(num_, 0, block_ * sizeof(size_t));
        return *this;
    }
    size_t blockShift = shift / BLOCKBIT; // the shift of how many units of array  
    size_t innerShift = shift % BLOCKBIT; // the shift in the unit of array
    for (size_t i = 0; i < block_; i ++) {
        size_t opid = block_ - 1 - i;
        if (opid < blockShift) {
            num_[opid] = 0;
        } else {
            if (opid - blockShift > 0)
                num_[opid]=(num_[opid-blockShift]<<innerShift)|(num_[opid-blockShift-1]>>(BLOCKBIT-innerShift)); 
            else
                num_[opid] = num_[opid - blockShift] << innerShift;     
        }
    }
    return *this;
}

template<size_t len_> myBitset<len_>& myBitset<len_>::operator>>= (size_t shift)
{
    //  printf("%llu\n",num_[0]);
    if (shift == 0) return *this;
    if (shift >= len_) {
        memset(num_, 0, block_ * sizeof(size_t));
        return *this;
    }
    size_t blockShift = shift / BLOCKBIT; // the shift of how many units of array  
    size_t innerShift = shift % BLOCKBIT; // the shift in the unit of array
    for (size_t i = 0; i < block_; i ++) {
        if (i > block_ - 1 - blockShift) {
            num_[i] = 0;
        } else {
            if (i + blockShift + 1 < block_)
                num_[i]=(num_[i+blockShift]>>innerShift)|(num_[i+blockShift+1]<<(BLOCKBIT-innerShift)); 
            else
                num_[i] = num_[i + blockShift] >> innerShift;       
        }
    }
//  printf("%llu\n",tbs.num_[0]);
    return *this;
}

template <size_t len_>  inline myBitset<len_>& myBitset<len_>::operator++ (void)
{
    (*this) += 1;
    return *this;
}
template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator++ (int dummy)
{
    myBitset<len_> tbs = (*this);
    ++ (*this);
    return tbs;
}
template <size_t len_>  inline myBitset<len_>& myBitset<len_>::operator-- (void)
{
    (*this) -= 1;
    return *this;
}
template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator-- (int dummy)
{
    myBitset<len_> tbs = (*this);
    -- (*this);
    return tbs;
}

template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator+ (const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs += bs;
    return tbs;
}
template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator- (const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs += -bs;
    return tbs;
}
template <size_t len_>  inline myBitset<len_>& myBitset<len_>::operator-= (const myBitset& bs)
{
    *this += -bs;
    return *this;
}

template <size_t len_>  inline myBitset<len_>& myBitset<len_>::operator+= (myBitset bs)
{
    myBitset<len_> tbs;
    while ((bs)) {
        tbs = (*this) ^ bs;
        bs = (*this & bs) << 1;
        *this = tbs;
    }
    return *this;
}

template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator+ (void) const
{
    return *this;
}
template <size_t len_>  inline myBitset<len_> myBitset<len_>::operator- (void) const
{
    myBitset<len_> tbs(*this); 
    return ~(tbs) + 1;
}

template<size_t len_> myBitset<len_>::operator bool(void) const
{
    for (size_t i = 0; i < len_ ; i ++) {
        if (isTrue(i))
            return true;
    }
    return false;
}

template <size_t len_>  myBitset<len_>& myBitset<len_>::operator*= (myBitset bs)
{
    if (!bs || !*this) {
        *this = 0;
        return *this;
    }
    int flag = 0;
    myBitset<len_> tbs(*this);
    *this = 0;
    if (isTrue(len_ - 1)) {
        flag = ~flag;
        tbs = -tbs;
    }
    if (bs.isTrue(len_ - 1)) {
        flag = ~flag;
        bs = -bs; 
    }
    while (bs) {
        if (bs & 1) 
            *this += tbs;
        tbs <<= 1;
        bs >>= 1;
    }
    if (flag) {
        *this = -(*this);
    }
    return *this;
}

template <size_t len_>  myBitset<len_> myBitset<len_>::operator* (const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs *= bs;
    return tbs;
}

template <size_t len_>  myBitset<len_>& myBitset<len_>::operator/= (myBitset bs)
{
//  cout << *this << " " << bs << endl;
    if (bs) {
        int flag = 0;
        myBitset<len_> tbs(*this);
        *this = 0;
        if (tbs.isTrue(len_ - 1)) {
            flag = ~flag;
            tbs = -tbs;
        }
        if (bs.isTrue(len_ - 1)) {
            flag = ~flag;
            bs = -bs; 
        }
//      cout << tbs << " " << bs << endl;
        size_t highbit = 0;
        for (size_t i = len_ - 2; i > 0; i --) {
            if (tbs.isTrue(i)) {
                highbit = i;
                break;
            }
        }
        for (size_t i = 0; i <= highbit; i ++) {
            size_t op = highbit - i;
            // avoid overflow!!!
            if ((tbs >> op) >= bs) {
                tbs -= (bs << op);
                *this += (myBitset<len_>(1) << op);
            }
//          cout << op << " " << tbs << " " << bs << " " << *this << endl;
        }
        if (flag) {
            *this = -(*this);
        }
        return *this;
    } else {
        cout << "divisor cannot be 0 !" << endl;
        return *this;
    }

}
template <size_t len_>  myBitset<len_> myBitset<len_>::operator/ (const myBitset& bs) const
{
    myBitset<len_> tbs(*this);
    tbs /= bs;
    return tbs;
}


template <size_t len_> bool myBitset<len_>::operator>= (const myBitset& bs) const
{
    return (*this > bs || *this == bs);
}
template <size_t len_> bool myBitset<len_>::operator> (const myBitset& bs) const
{
    if (!isTrue(len_ - 1) && isTrue(len_ - 1)) {
        return true;
    } 
    if (isTrue(len_ - 1) && !isTrue(len_ - 1)) {
        return false;
    }

    for (size_t i = 0; i < block_; i ++) {
        size_t op = block_ - i - 1;
        if (num_[op] > bs.num_[op]) {
            return true;
        } 
        if (num_[op] < bs.num_[op]) {
            return false;
        }
    }
    return false;
}
template <size_t len_> bool myBitset<len_>::operator== (const myBitset& bs) const
{
    if (*this ^ bs) {
        return false;
    } else {
        return true;
    }
}
template <size_t len_> inline bool myBitset<len_>::operator< (const myBitset& bs) const
{
    return !(*this >= bs);
}
template <size_t len_> inline bool myBitset<len_>::operator<= (const myBitset& bs) const
{
    return !(*this > bs);
}
template <size_t len_> inline bool myBitset<len_>::operator!= (const myBitset& bs) const
{
    return !(*this == bs);
}

main.cpp
里面主要是测试

#include <iostream>
#include <cmath>
#include "bit.h"
#include <bitset>
using namespace std;

int main(int argc, char** argv) 
{   
    cout << (-11111 >> 30) << endl;
    cout << size_t(-1) << endl;
    cout << "test for set, reset and flip" << endl;
    myBitset<32> bt;
    bt.set(0);
    cout << bt << endl;
    bt.reset(0);
    cout << bt << endl;
    bt.set(31);
    cout << bt << endl;
    bt.flip();
    cout << bt << endl;

    cout << endl << "test for constructor" << endl;
    string s = "100010";
    myBitset<32> bt1;
    cout << bt1 << endl;
    myBitset<33> bt2(s);
    cout << bt2 << endl;
    myBitset<33> bt31(64);
    cout << bt31 << endl;
    myBitset<65> bt32(static_cast<unsigned long long>((size_t(1) << 63) + ((size_t(1) << 63) - 1)));
    cout << bt32 << endl;
    myBitset<33> bt4(bt31);
    cout << bt4 << endl;

    cout << endl << "test for <<, >> and =" << endl;
    myBitset<100> bt5(size_t(pow(2,31))+15);
    cout << bt5 << endl;
    cout << (bt5 << 4) << endl;
    cout << (bt5 >> 4) << endl;
    cout << (size_t(1) << 33) << endl; 
    myBitset<100> bt6("100000011111111111000010101");
    cout << bt6 << endl;
    bt6 = bt5;
    cout << bt6 << endl;
    myBitset<129> bt7 = string("10110011101111011111010101");
    cout << bt7 << endl;
    cout << (bt7 >> 7) << endl;
    cout << (bt7 << 7) << endl;
    cout << (bt7 << 65) << endl;
    cout << (bt7 >> 65) << endl;

    cout << endl << "test for &, |, ~ and ^" << endl;
    myBitset<70> bt8("1011011101111011111011111101111111011111111011111111101111111111011110");
    cout << bt8 << endl;
    myBitset<70> bt9(~bt8);
    cout << bt9 << endl;
    cout << (bt8 | bt9) << endl;
    cout << (bt8 & bt9) << endl;
    cout << (bt8 ^ bt9) << endl;
    cout << (bt8 ^ bt9 ^ bt8) << endl;

    cout << endl << "test for &=, |= and ^=" << endl;
    cout << bt8 << endl;
    bt8 &= bt9;
    cout << bt8 << endl;
    bt8 |= bt9;
    cout << bt8 << endl;
    bt8 ^= ~bt9 ^ 1;
    cout << bt8 << endl;

    cout << endl << "test for <<= and >>=" << endl;
    myBitset<70> bt10("1011011101111011111011111101111111011111111011111111101111111111011111");
    cout << bt10 << endl;
    cout << (bt10 << 65) << endl;
    bt10 <<= 65;
    cout << bt10 << endl;
    bt10 = string("1011011101111011111011111101111111011111111011111111101111111111011111");
    cout << (bt10 >> 65) << endl;
    bt10 >>= 65;
    cout << bt10 << endl;

    cout << endl << "test for + and -" << endl;
    bt9 = string("1011011101111011111011111101111111011111111011111111101111111111011111");
    bt10 = ~bt9;
    cout << bt9 << endl;
    cout << bt10 << endl;
    cout << (-bt9) << endl;
    cout << (-bt10) << endl;
    cout << (bt9 + bt10) << endl;
    cout << (bt9 - (bt10>>3)) << endl;
    bt9 = -1;
    bt10 = 64;
    cout << (bt9 + bt10) << endl;
    cout << (bt9 - bt10) << endl;

    cout << endl << "test for ++, -- , += and -=" << endl;
    bt9 = string("1011011101111011111011111101111111011111111011111111101111111111011111");
    bt10 = ~bt9;
    cout << (bt9 ++) << endl;
    cout << bt9 << endl;
    cout << (bt10 --) << endl;
    cout << bt10 << endl;
    cout << (++ bt9) << endl;
    cout << bt9 << endl;
    cout << (-- bt10) << endl;
    cout << bt10 << endl;
    bt10 += 1;
    cout << bt10 << endl;
    bt10 -= 3;
    cout << bt10 << endl;

    cout << endl << "test for *, *=, /, /=" << endl;
    bt9 = -13;
    bt10 = 3;
    bt9 *= bt10;
    cout << bt9 << endl;
    cout << (bt9 * bt10) << endl;
    bt9 *= -3;
    bt10 *= 100;
    cout << bt9 << endl;
    cout << bt10 << endl;

    cout << endl << "test for /, /=" << endl;
    bt9 = 10;
    bt10 = 3;
    cout << (bt9 >= bt10) << endl;
    cout << (bt9 >> 3) << endl;
    cout << ((bt9 >> 3) >= bt10) << endl;
    cout << (bt9 << 0) << endl;
    cout << (myBitset<70>(1) << 0) << endl;
    bt9 /= bt10;
    cout << bt9 << endl;
    bt9 = -10;
    bt10 = 3;
    cout << (bt9 / bt10) << endl;
    cout << (bt10 / bt9) << endl;

    return 0;
}

附：实验报告

第一次实验报告

一、 题目分析

位运算的封装：
第一次看到这个题目，我想到了stl中的bitset，bitset实现了对bit类型数组的封装，同时支持六种位运算，我的目的就是实现类似于bitset的类模版。
六种位运算& | ~ ^ << >> 支持基础数据类型，但是基础数据类型的大小是固定的，不能支持bit数高于8 * sizeof(size_t)（最大一般是64bit）的要求，而且不能支持任意位数的bit类型数组，这样显然不能满足我们的要求。
因此，我决定使用size_t类型的数组，通过基础类型的位运算实现对每一个size_t内的位的操作,从而实现对抽象的“位类型”的操作。
除了最基础的构造函数、析构函数、拷贝运算符，实现了六种位运算，还实现了布尔类型的类型转换，逻辑运算，和+-*/四则运算和自增自减运算以及流插入操作符重载。

100！的计算：
首先想到的是高精度乘法，通过数组存储大数的每一位，模拟竖式乘法，从而得解。

二、 流程分析（感觉太复杂了画图有些困难，所以通过文字描述）

这里介绍位运算封装的流程，大数阶乘比较简单。
1. 构造函数：
共9个，最基础的是默认构造函数，在其中完成相关变量初始化和内存空间的申请。
之后是拷贝构造函数，myBitset(unsigned __int64 num); myBitset(const string& s); 它们首先使用默认构造函数进行委托构造，之后再实现自己特定的构造。
在之后是以其他各种无符号或有符号整数做参数的构造函数，它们使用myBitset(unsigned __int64 num);进行委托构造，从而完成功能。
2.基础功能的实现
共4个，分别是
void flip();
void set(size_t index);
void reset(size_t index);
bool isTrue(size_t index) const;
flip实现按位取反，set实现对下标是index的置1，reset是实现对下标是index的置0，isTrue判断下标为index的位是否是1，接下来的许多函数都是需要直接或者间接调用这些函数的。
2. 位运算运算符以及=的重载
myBitset& operator= (const myBitset& bs);
myBitset operator& (const myBitset& bs) const;
myBitset operator| (const myBitset& bs) const;
myBitset operator~ (void) const;
myBitset operator^ (const myBitset& bs) const;
myBitset operator<< (size_t shift) const;
myBitset operator>> (size_t shift) const;
myBitset& operator&= (const myBitset& bs);
myBitset& operator|= (const myBitset& bs);
myBitset& operator^= (const myBitset& bs);
myBitset& operator<<= (size_t shift);
myBitset& operator>>= (size_t shift);
首先实现的是&= |= 等函数，之后& |等运算符通过调用&= |= 等实现功能。
3. 四则运算与自增自减
myBitset& operator++ (void);
myBitset& operator– (void);
myBitset operator++ (int dummy);
myBitset operator– (int dummy);
myBitset& operator+= (myBitset bs);
myBitset& operator-= (const myBitset& bs);
myBitset operator+ (const myBitset& bs) const;
myBitset operator- (const myBitset& bs) const;
myBitset operator+ (void) const;
myBitset operator- (void) const;

    myBitset operator* (const myBitset& bs) const;
    myBitset operator/ (const myBitset& bs) const;
    myBitset& operator*= (myBitset bs);
    myBitset& operator/= (myBitset bs);

同样，首先实现的是+= -=等，对应的双目运算符则调用前者，单目-调用~运算符。
前置自增自减调用+= -=,而后置自增自减调用前置自增自减。
4. 逻辑运算符与bool类型转换
bool operator> (const myBitset& bs) const;
bool operator>= (const myBitset& bs) const;
bool operator< (const myBitset& bs) const;
bool operator<= (const myBitset& bs) const;
bool operator== (const myBitset& bs) const;
bool operator!= (const myBitset& bs) const;
explicit operator bool(void) const;
bool类型转换函数调用isTrue函数。
实现的是>和==，其他逻辑运算符直接或间接调用这两个函数。

三、程序难点以及遇到的主要bug

1.构造函数
为了支持四则运算，必须提供参数无符号整型和有符号整型的构造函数，开始我只定义了unsigned __int64和 signed __int64为参数的构造函数，然而这时就会遇到二义调用的问题。
为了避免二义调用，我为常见的整型类型分别定义了构造函数。
2.移位运算
因为存储位的是数组，故实现移位操作时会遇到困难，通过寻找规律可以解决这一问题。
此外还遇到了如下问题。

一开始我并没有对1进行强制类型转换，转换成myBitset类型，按道理，1移位超过int位长时，这样会使1移位后的结果变成0（逻辑移位），但是，这里实际上竟然是循环移位。
而单单对1进行左移位，得到的结果是逻辑移位的结果。
目前还是没有弄明白是为什么。

因为首先实现的是<<=和>>= ，<< >>是通过调用<<= >>= 实现的，移位的时候可能会出现运算结果覆盖未进行运算数据的情况，所以要注意运算的顺序，>>要先从低位开始算，<<要先从高位开始算。

还遇到了移位0时出现的错误，需要特判shift为0时的情况。（除法调用移位操作时发现）
3.bool类型转换
一开始并没有把operator bool 声明为explicit，于是出现了双目运算符调用时的二义调用（左操作数为myBitset对象而右操作数为基础数据类型时），因为myBitset可以隐式的转换为bool类型，c++中bool类型实质上就是int类型。
在查资料之前，我尝试了在声明中加入了explicit关键字，尽管在我的印象中它只能用在构造函数的声明中，但是问题的确解决了，后来查资料发现，在c++11标准中，允许在类型转换运算符前加入explicit的声明，而对bool则更加特殊，在条件表达式中它允许隐式转换而在其他情况中只允许显式使用。
5. 不小心就会发生的间接递归
由于一些运算符要通过调用其他运算符实现，所以在头脑不清晰的情况下极易发生
递归，而且这类错误比较难发现，程序中出现的最长间接递归链甚至可达10个以上的函数。
6. 乘法与除法
在设计乘法的算法时我借鉴了快速幂算法的思想，只不过当第二个乘数为奇数时ans变量做的运算由乘变成了加，只要调用加法就可以实现乘法了。
除法就是乘法的逆运算。
7. size_t类型
size_t类型是一种无符号整数类型，具体类型依赖于环境，但它是非负的，用size_t类型做循环变量时，由于它不可能小于0，于是下面的语句会出现死循环。
For (size_t I = len_ - 1; I >= 0; I ++)
故程序中所有循环尽量写成正序的，需要反向的顺序时，通过循环变量计算出实际运算的下标。

四、 优点与缺点

封装位运算操作符
优点：
a) 实现了任意长度的位类型
b) 满足了所有的要求
c) 尽量使用已定义的方法去定义其他方法
d) 对于多个方法（已实现的或是以后可能实现的）会使用的相同方法，将该方法定义为一个函数
e) 实现了四则运算，自增自减，重载了流插入操作符。
缺点：
a) 最重大的失误：没有将二元运算符用非成员函数实现。（3 + myBitset<10>(1)是非法的）
b) 没有实现[]操作符。（代理模式）
c) 没有用myBitset类实现阶乘（主要是没有转换成整型的方法）
d) 没有定义将myBitset转换为整型的方法（大数进制转换）
e) 部分方法效率不高

nnbs
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php封装的page分页类.zip
07-11
主要介绍了php封装的page分页类,结合完整实例形式分析了php数值运算与字符串操作实现分页功能的相关技巧,需要的朋友可以参考下。
php封装的page分页类完整实例
10-21
主要介绍了php封装的page分页类,结合完整实例形式分析了php数值运算与字符串操作实现分页功能的相关技巧,需要的朋友可以参考下
C与C++位运算封装代码.rar
03-21
C与C++位运算封装代码
Java使用BigDecimal进行运算封装的实际案例
08-26
今天小编就为大家分享一篇关于Java使用BigDecimal进行运算封装的实际案例，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
AD运算放大器芯片元件封装
04-26
AD运算放大器芯片元件封装
C语言位运算的封装
u013441358的专栏
08-20 567
目录背景介绍源码说明 背景介绍 位运算就是直接对整数在内存中的二进制位进行操作，它是C语言的强大的特性之一。 功能 位运算符 说明 按位与 a & b 按位或 a | b 按位异或 a ^ b 按位取反 ~a 左移 a << b a左移b位，就是a乘以2的b次方 右移 a >> b a右移b位，就是a除以2的b次方 需要注意它与逻辑运算的区分。 功能 逻辑运算符 逻辑与 a && b 逻辑或
位操作封装
m0_38126105的博客
12-12 199
#ifdef _WIN32 #include <windows.h> #else #define byte unsigned char #endif /**************************************************************************** * 函数功能：获取指定位的值 * @param n 值 * m ...
c++ template(三)
风吟
05-13 278
对于函数模板和类模板的参数并不局限于类型，普通值也可以作为模板的参数。那非类型的模板形参有什么用呢？在什么情况下我们要使用非类型的模板形参呢？答：当我们构建栈模板时，为了更好的使用栈模板，我们可以让用户自定义栈的大小。也就是说在一些特定的情况下，为了满足要求必须让用户自定义一些所设计的东西的大小，这时候我们就需要为模板指定非类型的参数。 首先我们先来看看类模板的非类型模板实参 templat...
C++自动化(模板元)编程基础与应用(5)
Augusdi的专栏
02-01 511
#if 0 在上一篇文章里面讨论了C++里面的代码生成技术，使用的是scatter，不过上一篇文 章里面也提到了，前一篇文章里面讨论的代码生成模板scatter使用的类型串绝对不允许 重复。其实上一篇中的scatter使用由重复的类型的类型串也是能够正常生成代码的，不 过产生的代码却不能将类型重复的变量分辨出来，这样生成的代码就没有了什么实际意义 ，所以在这一章中将要解决的问题是：重新编写一个可以使用重复类型的类型串生成代码 ，并且能够采用一定的方法将这些生成的变量分辨出来。 那么该如何...
常见的位操作进行封装
wotaifuzao的博客
10-19 218
#define BIT_JUDGE(Val,Bit) ((Val>>Bit)&0x01) /* 位判断 / #define BIT_SET(Val,Bit) (Val |= (1<<Bit)) / 位置1 / #define BIT_CLEAR(Val,Bit) (Val &= ~(1<<Bit)) / 位置0 / #define BIT_INVERT(Val,Bit) (Val
吉林大学软件学院卓班C++所有实验课实验报告和代码
10-21
吉林大学软件学院卓班C++实验课实验报告和代码共七次 第一次题目如下 一、实验题目 （1）位运算封装 建立一个类封装C语言中的6种位运算（函数接口封装），给出调用测试。 基于位运算模拟+、-、*三种运算，给出调用测试。 （2）实现一个整数中所有数字累加和的计算。 （3）给出1000！的计算，可以采用任意方法。 报告要求： （1）详细描述题目要求； （2）画出主要流程图，并给出必要的文字说明； （3）分析程序难点，并讨论解决问题思路。 （4）分析所实现程序的优点和缺点。 （5）你的收获；
大学C/C++软件课程设计报告
04-16
这是我大二的软件课程设计报告,编程语言c++，包括多个程序源代码，包括了用迭代法求a的立方根、从键盘输入正整数n，求出n与其反序数之和并输出、自定义一个示意性的复数类型complex、编写一个具有类模板tmplt，用于实现所谓的反序输出问题、用你熟悉的一种可视化编程语言实现计算器、单机版俄罗斯方块、编一程序对至少三个排序方法进行比较、编写程序，让计算机来猜测用户“暗记”的某张扑克牌
JAVA实验报告二Java面向对象程序设计.docx
08-23
实验二Java面向对象程序设计 (1)定义表示课程的类Course，课程的属性包括课程名、编号、先修课号；方法包括设置课程名、设置编号、设置先修课号，以及打印课程名、课程号、先修课号。编写主程序，创建Course类的对象...
西北工业大学软件学院面向对象程序设计实验课程大作业
06-11
西北工业大学软件学院面向对象程序设计实验课程大作业，欢迎大家下载！
c++面向对象程序设计结课作业-造型棋.zip
01-28
c++面向对象程序设计课程的结课作业，一个名为造型棋的小游戏，使用qt制作，里面包含了源代码和结课报告。仅供学习参考。
完成Java面向对象程序设计实验课的心得体会
07-02
经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性，以及Java对我们专业的发展发挥的作用。在上个学期我们也学习了Java语言程序设计基础，在此基础之上学习起来就方便了一些，做其实验来也会...
JAVA语言与面向对象程序设计课后习题答案.pdf
08-28
JAVA语言与面向对象程序设计课后习题答案
面向对象程序设计第二次实验课——mystring类实现
nNbS
05-09 841
#pragma once #include <cstring> #include <iostream> using namespace std; const size_t MAX_CHAR_IN_NODE = 100; // 定义链块 struct Node { char s[MAX_CHAR_IN_NODE]; Node *next; };class myString; mySt
面向对象程序设计c++实验 武汉理工
最新发布
11-20
总之，面向对象程序设计C实验是武汉理工大学计算机科学与技术专业学生必修的重要课程之一，通过这门实验课，学生将能够系统地学习和掌握面向对象程序设计的知识和技能，提高自己的编程能力和解决问题的能力。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值