Question

我需要构建bitset的2D数组，我想从用户那里获得数组的大小和bitset的大小。由于其模板和值必须为const，我该怎么做？

int main(int argc, char* argv[]) {
int const LEN ;
int const NUMBER;
if ( argc == 3 ) 
{
    LEN =  atoi(argv[1]);
    NUMBER =  atoi(argv[2]);
}
else{
    LEN = 1000;
    NUMBER = 800;
}
bitset<LEN> b[NUMBER];
}

Answer 1

你做不到。您需要知道编译时的大小才能使用bitset。您可以使用vector<bool>作为替换，这实际上是一个向量，而不是实际bool的向量。

Answer 2

如果你可以设置一个限制，你可以使用的比特集大小，你可以作弊。

// invokes target<i>{}() if i >= min and i < max
template<template<size_t>class target, size_t max, size_t min=0>
struct magic_switch {
  void operator()( size_t i ) const {
    constexpr size_t mid = (min+max-1)/2;
    if (i==max-1) target<max-1>{}();
    else if(i<mid) magic_switch<target, mid,min>{}(i);
    else magic_switch<target, max-1,mid>{}(i);
  }
};
template<template<size_t>class target, size_t min>
struct magic_switch<target, min, min> {
  void operator()( size_t i ) const {} // do nothing
};
int number;
template<size_t len>
struct program {
  template<size_t number>
  struct p2 {
    void operator()() const {
      std::bitset<len> arr[number];
      // code
    }
  };
  void operator()() const {
    magic_switch<p2, 1001, 1>{}(number);
  }
};

int main(int argc, char const* argv[]) {
  int len;
  if ( argc == 3 ) 
  {
    len =  atoi(argv[1]);
    number =  atoi(argv[2]);
  }
  magic_switch<program, 1001, 1>{}( len );
}

当然，这种做法完全是疯子，也是一个坏主意。

基本上我创建了10000000个程序，每个len x编号一个，然后进行大量链接，如果找出要运行的程序。

通过将指针存储在数组中的程序，然后执行数组查找而不是20深度递归，可以使性能更高。这仍然是一个坏主意。

请勿使用此解决方案。如果你不明白为什么你不应该使用它，那么请相信我。如果您确实理解为什么不应该使用它，那么这一段就是多余的。

更快magic_switch（某些编译器不喜欢它，并使用C ++ 14功能）：

template<template<size_t>class target, size_t max, size_t min=0>
struct magic_switch {
  template<size_t...Is>
  void operator()( std::index_sequence<Is...>, size_t i ) {
    using task = void(*)();
    static const task arr[] = {
      []{ target<min+Is>{}(); }...
    };
    arr[i-min]();
  }
  void operator()( size_t i ) const {
    (*this)( std::make_index_sequence<max-min>{}, i );
  }
};

这里我们构建一个跳转表（在static const数组中），执行查找并执行它。

将此扩展为take / return args相对容易：

template<class Sig, template<size_t>class target, size_t max, size_t min=0>
struct magic_switch;
template<class R, class...Args, template<size_t>class target, size_t max, size_t min>
struct magic_switch<R(Args...), target, max, min> {
  template<size_t...Is>
  R operator()( std::index_sequence<Is...>, size_t i, Args&&...args ) {
    using task = R(*)(Args&&...);
    static const task arr[] = {
      [](Args&&...args)->R{
        return target<min+Is>{}(std::forward<Args>(args)...);
      }...
    };
    return arr[i-min](std::forward<Args>(args)...);
  }
  R operator()( size_t i, Args...args ) const {
    return (*this)(
      std::make_index_sequence<max-min>{},
      i,
      std::forward<Args>(args)...
    );
  }
};

使用这个将取消number变量全局存储的要求。由于全局变量是不好的做法，这改善了代码。

Answer 3

简单的答案是 - 你不能这样做。 std::bitset使用编译时值。

您可以使用vector<bool>或加强库的dynamic_bitset：

http://www.boost.org/doc/libs/1_57_0/libs/dynamic_bitset/dynamic_bitset.html

基于输入参数初始化C ++数组

3 个答案: