这是直接在位集上的平凡inplace方法：

template<std::size_t N>
void reverse(std::bitset<N> &b) {
    for(std::size_t i = 0; i < N/2; ++i) {
        bool t = b[i];
        b[i] = b[N-i-1];
        b[N-i-1] = t;
    }
}

更少的代码将为您在TopCoder SRM中赢得一些时间。以下是我在TopCoder SRM中使用的代码（请参见here直播）：

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

int main() {
  auto x = std::bitset<32>(10);
  std::cout << x << std::endl;

  auto str = x.to_string();
  std::reverse(str.begin(), str.end());
  auto y = std::bitset<32>(str);
  std::cout << y << std::endl;

  return 0;
}

不使用任何标准库函数（除了打印结果之外）：

#include<iostream>
#include<bitset>

const int size = sizeof(int)*CHAR_BIT;

int main()
{
    int x = 10;
    int r = 0;
    for(int i = 0; i < size; i++)
    {
        r = r << 1 | (x & 1);
        x >>= 1;
    }
    std::bitset<size> bits(r);
    std::cout << "Reverse " << bits << std::endl;

}

请检查这一种方法：）

#include <iostream>
#include <bitset>

template<std::size_t N>
std::bitset<N> reverse(const std::bitset<N> &bit_set) {
  std::bitset<N> reversed;
  for (int i = 0, j = N - 1; i < N; i++, j--) {
    reversed[j] = bit_set[i];
  }
  return reversed;
}

int main() {
  std::bitset<32> b1(10);
  std::bitset<32> reversed_b1 = reverse(b1);
  std::cout << b1;
  std::cout << "\nand reversed\n" << reversed_b1 << std::endl;
  return 0;
}

uint32_t reverseBits(uint32_t n) {
    bitset<32> b(n);                       // store in binary form 
    string s=b.to_string();               //put it in string
    string k(s.rbegin(),s.rend());       //reverse string
    bitset<32>d(k);                      //again put new string k  in bitset
    return  d.to_ulong();               //get value in decimal form
    
    
}

这个问题的目的是为了公平的时间比较而设置缓存条件。解决这个问题要完全按照提问的方式。
与其该高速缓存中逐出所有内容（如果您看到分页效应，这可能代价非常高），不如将所有相关内存故障恢复到一致状态，这可能要简单得多。
也就是说，设计一个简短的例程，以特定的顺序触及你所关心的一切。在每次计时运行之前（以及收集开始标记之前）立即执行它。
有了它，您就可以确切地知道当您开始计时时缓存的状态应该是什么。
这实际上并不能解决您面前的整个问题，但是，如果您可以在单用户模式下运行例程和/或在具有统计累加器的轻负载系统上分别运行它们，那么它可能就足够了。