Question

还有其他方法可以重写这段代码吗？

if(i == 0 || i == 4 || i == 6 || i == 8 || i == 9 || i == 19 || i == 198 || i == 41 )
{
     // do something
}

在if条件中忽略多次检查的另一种方法是什么...我们在C ++中有什么类似 IN语句（SQL查询）的东西吗？..提前感谢..

Answer 1

通常情况下，编写新函数可能非常优雅：

template <typename Range, typename T>
bool contains(Range range, T element) {
    return std::find(std::begin(range), std::end(range), element) != std::end(range);
}

template <typename T>
bool contains(std::initializer_list<T> range, T element) {
    return contains<std::vector<int>>(range, element);
}

我选择了基于范围的方法，但是你也可以提供带开始/结束迭代器的重载。另外，在实现中随意使用std::find之外的其他内容。

（我们真的必须为std::initializer_list重载吗？似乎很奇怪我们无法推断它。）

现在我们可以写：

if (contains({1, 2, 3, 4, 5}, 3))

Answer 2

使用静态const无序集：

static const std::unordered_set<int> my = { 1 , 1 , 2 , 3 , 5 , 8 , 13 } ;

auto find = my.find( 8 ) ;
if( find != my.end() )
{
    cout << "found:" << *find << endl ;
}

搜索复杂度平均为O（1）。

并且应该是线程安全的。

Answer 3

一个简单的开关案例是最具可读性的：</ p>

   switch (i) {
      case 0:
      case 4:
      case 6:
      case 8:
      case 9:
      case 19:
      case 198:
      case 41:
        // DO THINGS
        break;
      default:
        // OTHERS
    }

Answer 4

static const int options[] = {0, 4, 6, 8, 9, 19, 198, 41};
if (std::find(std::begin(options), std::end(options), i) != options.end()) {
    // do something
}

如评论中所述，只要您保持选项排序，就可以使用此

static const int options[] = {0, 4, 6, 8, 9, 19, 198, 41};
if (std::binary_search(std::begin(options), std::end(options), i)) {
    // do something
}

应该更快。

对于小阵列，我认为选择哪种变体并不重要。

Answer 5

好吧，在C（当然还有C ++）中，您可以：

switch(i)
{
   case 0:
   case 4:
   case 6:
   case 8:
   case 9:
   case 19:
   case 198:
   case 41:  // do something
             break;
}

当然，编译器会生成几乎与原始ifs相同的代码，但这可能看起来更清楚了吗？

Answer 6

写这样的陈述是一个错误

if(i = 0 || i = 4 || i = 6 || i = 8 || i = 9 || i = 19 || i = 198 || i = 41 )

您需要使用==运算符进行比较。现在，因为您正在将一种类型的值与多种值进行比较。使用switch语句是更好的解决方案。快乐编码

Answer 7

使用带有std :: any_of：

的初始化列表（或向量）

static const auto accepted = { 0, 4, 6, 8, 9, 19, 198, 41 };
if( std::any_of(std::begin(accepted), std::end(accepted),
    [&i](int x) { return i == x; }) {

    // do something
}

（这是@JosephMansfield在评论中提出的）

编辑：可以通过重新排序整数值来优化，优先考虑最大命中值。

Answer 8

您可以使用STL MAP ...试试这个..

#include<cstdio>
#include<map>
using namespace std;

map<int,int>mp;
int main()
{
    int i;

    mp[0]=mp[4]=mp[6]=mp[8]=mp[9]=mp[19]=mp[198]=mp[41]=1;
    scanf("%d",&i);
    if(mp[i])
    {
        //do something
    }
    return 0;
}

Answer 9

使用这样的简短固定列表，您可以查找整数n，使得所有元素在除以n时具有不同的余数。例如，n = 14可以解决问题，因为余数mod 14分别为0,4,6,8,9,5,2和13.所以你可以这样做：

static const int remainder_table[14] = {
    0, 0, 198, 0, 4, 19, 6, 0, 8, 9, 10, 0, 0, 41
} ;
if (remainder_table[i % 14] == i) {
    // do something
}

警告：这不一定比原始if声明更快！这取决于硬件划分的速度和编译器的优化能力。

Answer 10

如果要将i与常量（在编译时已知）进行比较，则可以使用TMP。

namespace detail
{
    template <int ...Args>
    struct CompFunc;

    template <int num, int ...Args>
    struct CompFunc<num, Args...>
    {
        static constexpr bool f(int i)
        {
            return (i == num) || CompFunc<Args...>::f(i);
        }
    };
    template <>
    struct CompFunc<>
    {
        static constexpr bool f(int i)
        {
            return false;
        }
    };
}

template <int ...Args>
constexpr bool any_of_const(int i)
{
    return detail::CompFunc<Args...>::f(i);
}

和

if (any_of_const<0, 4, 6, 8, 9, 19, 198, 41>(i))
{
    ...
}

(live example)

在IF条件下交替进行多次检查

10 个答案: