[C++]bitset用int数组实现

最新推荐文章于 2024-07-26 08:16:39 发布
最新推荐文章于 2024-07-26 08:16:39 发布
阅读量2.5k 收藏 2
点赞数 2
分类专栏： C++编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stary_yan/article/details/50880120
版权

这并不是真正的bitset，只是用一些简单的c++知识来模仿bitset。

define N 5

const int max_length = 32 * N;//这个数字共有32*5位。从第0位到第max_length-1位，第0位是最低位。
class bitset {
private:
int a[N];//一个int32位，所以只用开N个int
public:
bitset();//默认构造函数，所有位初始化为0
void set(int pos);//把位置pos设置成1
void reset(int pos);//将位置pos设置成0
int count() const;//输出一共有多少个为1的位
bool test(int pos) const;//位置pos是否是1
bool any() const;//是否有是1的位
bool none() const;//是否没有是1的位
bool all() const;//是否所有位都是1

//位运算部分和普通数字的位运算相同。
bitset& operator&= (const bitset& b);
bitset& operator|= (const bitset& b);
bitset& operator^= (const bitset& b);
bitset& operator= (const bitset& b);
bitset& operator <<= (int pos);
bitset& operator >>= (int pos);
bitset operator~() const;
bitset operator&(const bitset& b) const;
bitset operator|(const bitset& b) const;
bitset operator^(const bitset& b) const;
bitset operator<<(int pos) const;
bitset operator>>(int pos) const;
bool operator== (const bitset& b) const;
bool operator!= (const bitset& b) const;
bool operator[] (int pos) const;//返回位置pos是不是1.

//输出部分已经实现
friend std::ostream& operator << (std::ostream& os, const bitset& s) {
for (int i = N-1; i >= 0; i–) {
for (int j = 31; j >= 0; j–) {
if (s.a[i] & (1 << j)) os << 1;
else os << 0;
}
}
return os;
}
};

练习点：只要定义少数关键的函数或操作符，就可以把其他函数和操作符实现。一定要学会用如何减少代码量。

#include<iostream>
#include"Bitset.h"
using namespace std;
int main() {
    bitset a, b;
    int n, m, q;
    cin >> n >> m >> q;
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        a.set(x);
    }
    cout << "a.count() is " << a.count() << "\n";
    cout << "a.test(5) is " << (a.test(5) ? "true" : "false") << "\n";
    cout << "a.any() is " << (a.any() ? "true" : "false") << "\n";
    cout << "a.none() is " << (a.none() ? "true" : "false") << "\n";
    cout << "a.all() is " << (a.all() ? "true" : "false") << "\n";
    b = ~b;
    for (int i = 0; i < m; i++) {
        int x;
        cin >> x;
        b.reset(x);
    }
    cout << a << "\n";
    cout << b << "\n";
    if (a == b) {
        cout << "hello\n";
    }
    if (a != b) {
        cout << "world\n";
    }
    bitset c;
    // test &
    c = a;
    c &= b;
    cout << c << "\n";
    c = a & b;
    cout << c << "\n";
    // test |
    c = a;
    c |= b;
    cout << c << "\n";
    c = a | b;
    cout << c << "\n";
    // test ^
    c = a;
    c ^= b;
    cout << c << "\n";
    c = a ^ b;
    cout << c << "\n";
    // test <<
    c = a;
    c <<= 2;
    cout << c << "\n";
    c = a << 2;
    cout << c << "\n";
    // test >>
    c = b;
    c >>= 2;
    cout << c << "\n";
    c = b >> 2;
    cout << c << "\n";
    // test []
    for (int i = 0; i < q; i++) {
        int x;
        cin >> x;
        if (a[i])
            cout << "Yes\n";
        else
            cout << "No\n";
    }
}
#ifndef BITSET_H
#define BITSET_H
#include<iostream>
#define N 5
const int max_length = 32 * N;
class bitset {
    private:
        int a[N];
    public:
        bitset();
        void set(int pos);
        void reset(int pos);
        int count() const;
        bool test(int pos) const;
        bool any() const;
        bool none() const;
        bool all() const;
        bitset& operator&= (const bitset& b);
        bitset& operator|= (const bitset& b);
        bitset& operator^= (const bitset& b);
        bitset& operator= (const bitset& b);
        bitset& operator <<= (int pos);
        bitset& operator >>= (int pos);
        bitset operator~() const;
        bitset operator&(const bitset& b) const;
        bitset operator|(const bitset& b) const;
        bitset operator^(const bitset& b) const;
        bitset operator<<(int pos) const;
        bitset operator>>(int pos) const;
        bool operator== (const bitset& b) const;
        bool operator!= (const bitset& b) const;
        bool operator[] (int pos) const;
        friend std::ostream& operator << (std::ostream& os, const bitset& s) {
            for (int i = N-1; i >= 0; i--) {
                for (int j = 31; j >= 0; j--) {
                    if (s.a[i] & (1 << j)) os << 1;
                    else os << 0;
                }
            }
            return os;
        }
};
#endif
#include "Bitset.h"
#include <string.h>
bitset::bitset() {
    memset(a, 0, sizeof(a));
}

bool bitset::test(int pos) const {
    int x = pos / 32;
    if (a[x] & (1 << (pos % 32))) {
        return true;
    } else {
        return false;
    }
}

void bitset::set(int pos) {
    int x = pos / 32;
    if (!test(pos)) {
        a[x] += 1 << (pos % 32);
    }
}

void bitset::reset(int pos) {
    int x = pos / 32;
    if (test(pos)) {
        a[x] -= 1 << (pos % 32);
    }
}

int bitset::count() const {
    int sum = 0;
    for (int i = 0; i != 160; i++) {
        if (test(i)) {
            sum++;
        }
    }
    return sum;
}

bool bitset::any() const {
    for (int i = 0; i != 160; i++) {
        if (test(i)) {
            return true;
        }
    }
    return false;
}

bool bitset::none() const {
    return !any();
}

bool bitset::all() const {
    for (int i = 0; i != 160; i++) {
        if (!test(i)) {
            return false;
        }
    }
    return true;
}

bitset& bitset::operator&=(const bitset &b) {
    for (int i = 0; i != 160; i++) {
        if (test(i) && b.test(i)) {
            set(i);
        } else {
            reset(i);
        }
    }
    return *this;
}
bitset& bitset::operator|=(const bitset &b) {
    for (int i = 0; i != 160; i++) {
        if (test(i) || b.test(i)) {
            set(i);
        } else {
            reset(i);
        }
    }
    return *this;
}
bitset& bitset::operator^=(const bitset &b) {
    for (int i = 0; i != 160; i++) {
        if ((test(i) && !b.test(i)) || (!test(i) && b.test(i))) {
            set(i);
        } else {
            reset(i);
        }
    }
    return *this;
}
bitset& bitset::operator=(const bitset &b) {
    for (int i = 0; i != 160; i++) {
        if (b.test(i)) {
            set(i);
        } else {
            reset(i);
        }
    }
    return *this;
}
bool bitset::operator[](int pos) const {
    if (test(pos)) {
        return true;
    } else {
        return false;
    }
}
bitset& bitset::operator <<= (int pos) {
    bitset temp(*this);
    memset(a, 0, sizeof(a));
    for (int i = 0; i != 160 - pos; i++) {
        if (temp.test(i)) {
            set(i + pos);
        } else {
            reset(i + pos);
        }
    }
    return *this;
}
bitset& bitset::operator>>=(int pos) {
    bitset temp(*this);
    memset(a, 0, sizeof(a));
    for (int i = 0; i != 160; i++) {
        if (temp.test(i)) {
            set((i - pos) % 159);
        } else {
            reset((i - pos) % 159);
        }
    }
    for (int i = 0; i != pos; i++) {
        set(159 - i);
    }
    return *this;
}
bitset bitset::operator~() const {
    bitset temp;
    memset(temp.a, 0, sizeof(temp.a));
    for (int i = 0; i != 160; i++) {
        if (test(i)) {
            temp.reset(i);
        } else {
            temp.set(i);
        }
    }
    return temp;
}

bitset bitset::operator&(const bitset& b) const {
    bitset answer;
    for (int i = 0; i != 160; i++) {
        if (test(i) && b.test(i)) {
            answer.set(i);
        } else {
            answer.reset(i);
        }
    }
    return answer;
}
bitset bitset::operator|(const bitset& b) const {
    bitset answer;
    for (int i = 0; i != 160; i++) {
        if (test(i) || b.test(i)) {
            answer.set(i);
        } else {
            answer.reset(i);
        }
    }
    return answer;
}
bitset bitset::operator^(const bitset& b) const {
    bitset answer;
    for (int i = 0; i != 160; i++) {
        if ((test(i) && !b.test(i)) || (!test(i) && b.test(i))) {
            answer.set(i);
        } else {
            answer.reset(i);
        }
    }
    return answer;
}
bitset bitset::operator<<(int pos) const {
    bitset temp;
    for (int i = 0; i != 160; i++) {
        if (test(i)) {
            temp.set(i + pos);
        } else {
            temp.reset(i + pos);
        }
    }
    return temp;
}
bitset bitset::operator>>(int pos) const {
    bitset temp;
    for (int i = 0; i != 160; i++) {
        if (test(i)) {
            temp.set((i - pos) % 159);
        } else {
            temp.reset((i - pos) % 159);
        }
    }
    for (int i = 0; i != pos; i++) {
        temp.set(159 - i);
    }
    return temp;
}
bool bitset::operator == (const bitset& b) const {
    for (int i = 0; i != 160; i++) {
        if (test(i) != b.test(i)) {
            return false;
        }
    }
    return true;
}
bool bitset::operator!= (const bitset& b) const {
    return !(*this == b);
}

答案：

#include"Bitset.h"
bitset::bitset() {
    for (int i = 0; i < N; i++) a[i] = 0;
}
void bitset::set(int pos) {
    int x = pos / 32;
    int y = pos % 32;
    a[x] |= 1 << y;
}
void bitset::reset(int pos) {
    int x = pos / 32;
    int y = pos % 32;
    a[x] &= ~(1 << y);
}
int bitset::count() const {
    int sum = 0;
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < 32; j++) {
            if (a[i] & (1 << j)) sum++;
        }
    }
    return sum;
}
bool bitset::test(int pos) const {
    int x = pos / 32;
    int y = pos % 32;
    return (a[x] & (1 << y));
}
bool bitset::any() const {
    return count() > 0;
}
bool bitset::none() const {
    return count() == 0;
}
bool bitset::all() const {
    return count() == max_length;
}
bitset& bitset::operator&= (const bitset& b) {
    for (int i = 0; i < N; i++) a[i] &= b.a[i];
    return *this;
}
bitset& bitset::operator|= (const bitset& b) {
    for (int i = 0; i < N; i++) a[i] |= b.a[i];
    return *this;
}
bitset& bitset::operator^= (const bitset& b) {
    for (int i = 0; i < N; i++) a[i] ^= b.a[i];
    return *this;
}
bitset& bitset::operator <<= (int pos) {
    while (pos--) {
        for (int i = N-1; i >= 0; i--) {
            if (i == 0) {
                a[i] <<= 1;
                continue;
            }
            a[i] <<= 1;
            if (a[i-1] & (1 << 31))
                a[i] |= 1;
            else
                a[i] &= ~1;
        }
    }
    return *this;
}
bitset& bitset::operator>>= (int pos) {
    while (pos--) {
        for (int i = 0; i < N; i++) {
            if (i == N-1) {
                a[i] >>= 1;
                continue;
            }
            a[i] >>= 1;
            if (a[i+1] & 1)
                a[i] |= 1 << 31;
            else
                a[i] &= ~(1 << 31);
        }
    }
    return *this;
}
bitset& bitset::operator= (const bitset& b) {
    for (int i = 0; i < N; i++) a[i] = b.a[i];
    return *this;
}
bitset bitset::operator~() const {
    bitset s;
    for (int i = 0; i < N; i++) s.a[i] = ~a[i];
    return s;
}
bitset bitset::operator& (const bitset& b) const {
    bitset s;
    s = *this;
    return s &= b;
}
bitset bitset::operator| (const bitset& b) const {
    bitset s;
    s = *this;
    return s |= b;
}
bitset bitset::operator^ (const bitset& b) const {
    bitset s;
    s = *this;
    return s ^= b;
}
bitset bitset::operator << (int pos) const {
    bitset s;
    s = *this;
    return s <<= pos;
}
bitset bitset::operator >> (int pos) const {
    bitset s;
    s = *this;
    return s >>= pos;
}
bool bitset::operator== (const bitset& b) const {
    for (int i = 0; i < N; i++)
        if (a[i] != b.a[i]) return false;
    return true;
}
bool bitset::operator!= (const bitset& b) const {
    for (int i = 0; i < N; i++)
        if (a[i] != b.a[i]) return true;
    return false;
}
bool bitset::operator[] (int pos) const {
    int x = pos / 32;
    int y = pos % 32;
    return a[x] & (1 << y);
}
stary_yan
关注
专栏目录
c++利用数组实现简单的奇偶校验
10-20
本文将深入探讨如何使用C++编程语言，通过数组实现对二进制数据进行奇偶校验。 首先，我们要理解奇偶校验的基本原理。奇偶校验基于一个简单的数学概念：在一个字符串（例如二进制序列）中，1的数量是奇数还是偶数。...
使用bitset实现二进制和十进制的相互转换
AC，∑ndless
09-26 9345
#include #include #include #include #include #include using namespace std; const int Size = 32; const double log_2 = log(2.0); char str[Size]; int main(void) { int num; char *endstr; while (~scan
bitset二进制转十进制
weixin_43479989的博客
11-29 2782
#include&lt;bits/stdc++.h&gt; using namespace std; int main() { bitset&lt;16&gt; bint; // 16 bit 二进制数据，还有 bitset&lt;32&gt; cin &gt;&gt; bint; cout &lt;&lt; bint.to_ulong() &lt;&lt; endl; } ...
C++ 标准库 ＜bitset＞
最新发布
Aforxiaoxie的博客
07-26 777
bitset 是C++标准库中一个非常有用的工具，它允许程序员以一种直观和高效的方式处理位级数据。位集合是一个由位（bit）组成的数组，每个位可以是0或1。例如，bitset<32> 表示一个包含32位的位集合。在 C++ 编程中，<bitset> 是标准库的一部分，它提供了一种方式来操作固定大小的位集合。// 从字符串初始化。// 循环遍历bitset中的位。// 声明一个大小为N的bitset。// 访问特定位置的位。// 访问位集合中的单个位。// 初始化bitset。
Bitset（十进制转二进制）
林下的码路
02-22 1429
Link：http://acm.hdu.edu.cn/showproblem.php?pid=2051 Bitset Time Limit: 1000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others) Total Submission(s): 14434    Accepted Submiss
关于vector数组和bitset
qq_41201839的博客
03-17 343
初始化 a.push_back(n); 翻转：reverse（a.begin(),a.end()） #include&lt;bits/stdc++.h&gt; using namespace std; int main() { vector&lt;int&gt; q[10]; for(int i=0;i&lt;10;i++) { q[i].resize(10); } q[0][0]=5; c...
bitset 用法整理
热门推荐
eecrazy的专栏
08-30 2万+
在项目中需要使用到10进制48位的数字按二进制由高到低解释，然后按每一位是0还是1来判断报警或错误状态。 所以，在Linux中的C++下需要用到二进制转换以及按位解析。收集到了一些资料，自己保存一下啊。   如下： bitset 用法整理 构造函数 bitset b; b有n位，每位都为0.参数n可以为一个表达式. 如bitset b0;则"b0"为"00000";
c++ bitset位运算
苦逼的程序猿
01-26 732
//1、初始化 bitset<32> bitvec(1U); //32位；低位为1，其他位为0 ////00000000000000000000000000000001 //cout << bitvec << endl; //bitvec1比初始值小；初始值中的高位被丢弃 bitset<13> bitvec1(0xbeef); //1111011101111 //cout << bitvec1 << endl; ..
C++离散数学真值表的实现.7z
07-12
在C++中实现这样的功能，我们可以使用二维数组来存储变量的取值和对应的表达式结果。首先定义一个足够大的二维数组，然后用位操作来表示布尔变量（通常0代表False，1代表True）。对于每个布尔变量，我们可以通过位移...
C++实现位图排序实例
09-04
在C++实现中，可以使用`std::bitset`容器，它的大小需要预先确定，并且可以像数组一样操作位。例如，如果最大整数是20，我们可以创建一个大小为21的`bitset`（包括0）。然后，通过`set()`函数将输入数组中的每个元素...
C++实现读入二进制数并转换为十进制输出
12-31
　很多学过C初学C++的人可能想到的是用字符数组形式读入再一位一位计算成十进制输出。 　没必要。 　C++类库提供了二进制数据类，并且可以用其方法转换成十进制。 　代码如下： 代码如下: #include using ...
动态Bitset源代码
09-30
在C++的STL中实现由一个bitset类模板，其用法如下： std::bitset<64> bs; 也就是说，这个bs只能支持64位以内的位存储和操作；bs一旦定义就不能动态增长了。本资源附件中实现了一个动态Bitset，和标准bitset兼容。 /*...
C++使用bitset处理二进制
天道酬勤
06-21 2166
标准库定义了bitset类处理二进制，当我们定义一个bitset时需要声明它包含的二进制位数量。 bitset初始化 bitset每一个二进制位默认初始化为0，当用整型值初始化bitset时，此值将转换为unsigned long long类型，如果二进制位数大于unsigned long long中二进制的位数，则剩余高位置为0，如果二进制位数小于unsigned long long中二进制的位...
bitset位向量用法-c++
DXT的博客
01-30 577
bitset 首先要导入bitset库 #include bitset初始化 举些例子： bitset foo; #16位全为0 输出： 0000000000000000 bitset foo(5); #共16位，值为5 输出： 0000000000000101 int h=1,m=1; bitset foo(h6|m);
位存储模板类：bitset
程序人生
05-27 376
为了使程序员更好地操作二进制位，C++STL定义了一个操作二进制位集合的模板类：bitset。 不指定初始值时，bitset的所有位都默认初始化为0。我们可以从一个string或一个字符数组指针来初始化bitset。两种情况下，字符都直接表示位模式，即字符串中下标最小的字符表示最高位，反之亦然。如果string包含的字符数比bitset少，则bitset的高位被置为0。bitset&lt;8&g...
c++ byte 转 int（C++基本类型整形）
luo809976897的专栏
06-20 2万+
c++本身不存在BYTE关键字。但在C++中byte可以用unsigned char来表示，即无符号类型。那么如何将C++ 中的Byte转成整形呢? 其实在C++中，无论是BYTE转int还是int转BYTE，都是可以借助对应的方法的，即c++ byte转int的方法是：bytesToInt();反过来int整形转BYTE的方法是intToByte();有了这个两个方法我们就可以把c++ b
遍历bitset中的1：_Find_first和_Find_next
zhangtingxiqwq的博客
08-14 373
【代码】遍历bitset中的1：_Find_first和_Find_next。
C++中判断数字某一位是否为1的方法之bitset
ISmileLi的博客
03-31 5279
一、问题描述：工作中遇到把一个数转化成32位后，判断某一位是否为1.没有使用逻辑运算符，直接使用C++提供的bitset，特别方便。 二、测试代码 #include #include using namespace std; int main() { // 00000000 00000000 00000000 00001000 bitset<32> tempBitset(8); b...
C++中把BYTE转换为int
sspdfn的专栏
04-03 3049
把BYTE转换为int也简单，直接用强制转换即可。 BYTE是一字节的，而int型是4字节，这是在转换中需要注意的。 如果只要把BYTE型的放在低位，则直接强制转换： BYTE byte=3; int a = (int)byte; //转换之后a = 3; 如果要把2个BYTE型的数据放在 int 的高位，就有点技巧了： BYTE byteArray[ ] = {3,2,
c++ bitset数组操作
12-30
以下是两个C++中使用bitset数组的例子： 1. 使用bitset数组输出二进制数 ```cpp #include #include <bitset> using namespace std; int main() { const unsigned bit_num = 13; bitset<bit_num> b1(0xbeef); ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值