C+中位集的字符串+； 我还是C++的新手，我想弄清楚我不能正确地把一个值传递给一个位集，至少我怀疑这就是问题所在。 我编写了一个小函数来帮助翻转十六进制值的位以反转endian。所以，示例将是输入0x01，它将返回0x80

这是我写的代码

int flipBits(char msd, char lsd) {

char ch[5];
sprintf_s(ch, "0x%d%d", msd, lsd);
char buffer[5];
strncpy_s(buffer, ch, 4);
cout << ch << endl;
cout << buffer << endl;
bitset<8> x(buffer);
bitset<8> y;

for (int i = 0; i < 8; i++) {
    y[i] = x[7 - i];
}

cout << y << endl;              // print the reversed bit order
int b = y.to_ulong();           // convert the binary to int

cout << b << endl;              // print the int
cout << hex << b << endl;       // print the hex


return b;
}

int翻转位（字符msd、字符lsd）{
char-ch[5]；
sprintf_s（ch，“0x%d%d”，msd，lsd）；
字符缓冲区[5]；
strncpy_s（缓冲区，通道4）；
cout我们可以编写类似stl的容器包装，这样我们就可以编写：

int main() {
    std::bitset<8> x(0x01);

    auto container = make_bit_range(x);
    std::reverse(container.begin(), container.end());

    std::cout << x << std::endl;
}

完整代码：

#include <iostream>
#include <bitset>
#include <algorithm>

template<std::size_t N>
struct bit_reference  {
    bit_reference(std::bitset<N>& data, int i) : data_(data), i_(i) {}

    operator bool() const { return data_[i_]; }
    bit_reference& operator=(bool x) {
        data_[i_] = x;
        return *this;
    }

    std::bitset<N>& data_;
    int i_;
};

template<std::size_t N>
void swap(bit_reference<N> l, bit_reference<N> r) {
    auto lv = bool(l);
    auto rv = bool(r);
    std::swap(lv, rv);
    l = lv;
    r = rv;
}


template<std::size_t N>
struct bit_range {
    using bitset_type = std::bitset<N>;

    bit_range(bitset_type &data) : data_(data) {}

    struct iterator {
        using iterator_category = std::bidirectional_iterator_tag;
        using value_type = bit_reference<N>;
        using difference_type = int;
        using pointer = value_type *;
        using reference = value_type &;

        iterator(bitset_type &data, int i) : data_(data), i_(i) {}

        bool operator==(iterator const &r) const { return i_ == r.i_; }

        bool operator!=(iterator const &r) const { return i_ != r.i_; }

        iterator &operator--() {
            return update(i_ - 1);
        }

        iterator &operator++() {
            return update(i_ + 1);
        }

        value_type operator*() const {
            return bit_reference<N>(data_, i_);
        }

    private:
        auto update(int pos) -> iterator & {
            i_ = pos;
            return *this;
        }

    private:
        bitset_type &data_;
        int i_;
    };

    auto begin() const { return iterator(data_, 0); }

    auto end() const { return iterator(data_, int(data_.size())); }

private:
    bitset_type &data_;
};

template<std::size_t N>
auto make_bit_range(std::bitset<N> &data) {
    return bit_range<N>(data);
}


int main() {
    std::bitset<8> x(0x01);

    auto container = make_bit_range(x);
    std::reverse(container.begin(), container.end());

    std::cout << x << std::endl;
}

#包括
#包括
#include
使用
std:：string
代替字符数组。最好从无符号字符而不是字符串构造位集
10000000

#include <iostream>
#include <bitset>
#include <algorithm>

template<std::size_t N>
struct bit_reference  {
    bit_reference(std::bitset<N>& data, int i) : data_(data), i_(i) {}

    operator bool() const { return data_[i_]; }
    bit_reference& operator=(bool x) {
        data_[i_] = x;
        return *this;
    }

    std::bitset<N>& data_;
    int i_;
};

template<std::size_t N>
void swap(bit_reference<N> l, bit_reference<N> r) {
    auto lv = bool(l);
    auto rv = bool(r);
    std::swap(lv, rv);
    l = lv;
    r = rv;
}


template<std::size_t N>
struct bit_range {
    using bitset_type = std::bitset<N>;

    bit_range(bitset_type &data) : data_(data) {}

    struct iterator {
        using iterator_category = std::bidirectional_iterator_tag;
        using value_type = bit_reference<N>;
        using difference_type = int;
        using pointer = value_type *;
        using reference = value_type &;

        iterator(bitset_type &data, int i) : data_(data), i_(i) {}

        bool operator==(iterator const &r) const { return i_ == r.i_; }

        bool operator!=(iterator const &r) const { return i_ != r.i_; }

        iterator &operator--() {
            return update(i_ - 1);
        }

        iterator &operator++() {
            return update(i_ + 1);
        }

        value_type operator*() const {
            return bit_reference<N>(data_, i_);
        }

    private:
        auto update(int pos) -> iterator & {
            i_ = pos;
            return *this;
        }

    private:
        bitset_type &data_;
        int i_;
    };

    auto begin() const { return iterator(data_, 0); }

    auto end() const { return iterator(data_, int(data_.size())); }

private:
    bitset_type &data_;
};

template<std::size_t N>
auto make_bit_range(std::bitset<N> &data) {
    return bit_range<N>(data);
}


int main() {
    std::bitset<8> x(0x01);

    auto container = make_bit_range(x);
    std::reverse(container.begin(), container.end());

    std::cout << x << std::endl;
}