C++ 将位设置为一，其中多个值的位都相同？

为了检测x和y的位在哪里不同，可以使用

XOR

：

z = ~(x^y)

将位设置为

x

和

y

的位相等的位

我也希望这样做，但有两个以上的价值观：

template <typename T0, typename... TN>
constexpr T0 same(const T0 x0, const TN... xn)
{
    // Something here
}

模板
常数T0相同（常数T0 x0，常数TN…xn）
{
//这里有东西
}

---

例如，对于4个值，

same（x0，x1，x2，x3）

将返回位设置为1的掩码，其中

x0

、

x1

、

x2

和

x3

的位都相等。怎么做？

可能是这样的：

z = (x0&x1&x2&x3) | (~x0&~x1&~x2&~x3); 
//In first bracket, get all bits that are 1, in second - all that are zero.

   template <typename T0, typename... TN>
    T0 same(const T0 x0, const TN... xn)
    {
        const int size = sizeof...(xn);
        int res[] = {xn...};
        T0 a1 = x0, a2 = ~x0;
        for (int i = 1; i < size; ++i){
            a1 &= res[i];
            a2 &= ~res[i];
        }
        return a1 | a2;
    }

模板
T0相同（常数T0 x0，常数TN…xn）
{
常数int size=sizeof…（xn）；
int res[]={xn…}；
t0a1=x0，a2=~x0；
对于（int i=1；i

可能是这样的：

   template <typename T0, typename... TN>
    T0 same(const T0 x0, const TN... xn)
    {
        const int size = sizeof...(xn);
        int res[] = {xn...};
        T0 a1 = x0, a2 = ~x0;
        for (int i = 1; i < size; ++i){
            a1 &= res[i];
            a2 &= ~res[i];
        }
        return a1 | a2;
    }

模板
T0相同（常数T0 x0，常数TN…xn）
{
常数int size=sizeof…（xn）；
int res[]={xn…}；
t0a1=x0，a2=~x0；
对于（int i=1；i

异或为两个相等的位保留一个零；当所有对向位相等时，OR保留零；而不是反转

对于

N

变量，操作计数为

N-1

xor、

N-2

or、

1

非（总计

2N-2

）

将此与使用的其他解决方案进行对比

2N-2

ANDs、

1

或

N

NOTs（总计

3N-1

），或

N-1

ANDs，

N

ORs，

1

NOT（总计

2N

）

异或为两个相等的位保留一个零；当所有对向位相等时，OR保留零；而不是反转

对于

N

变量，操作计数为

N-1

xor、

N-2

or、

1

非（总计

2N-2

）

将此与使用的其他解决方案进行对比

2N-2

ANDs、

1

或

N

NOTs（总计

3N-1

），或

N-1

ANDs，

N

ORs，

1

NOT（总计

2N

）

   template <typename T0, typename... TN>
    T0 same(const T0 x0, const TN... xn)
    {
        const int size = sizeof...(xn);
        int res[] = {xn...};
        T0 a1 = x0, a2 = ~x0;
        for (int i = 1; i < size; ++i){
            a1 &= res[i];
            a2 &= ~res[i];
        }
        return a1 | a2;
    }

~ ((x0 ^ x1) | (x0 ^ x2) | (x0 ^ x3) ... )