用于检查无符号short是否包含特定字节的C代码

我有一个

无符号short

值。它是从无线电源中采集的二进制数据。我想检查数据是否包含一个特殊的字节，一个签名字节

举例来说，

unsigned short

可能是

0100 1010 0111 0101 /* 0x4A75 */

我想检查它是否包含字节

1010 0111 /* 0xA7 */

任何地方。每次我检查时，检查的数据都会更改，但签名将保持不变

有人能帮忙吗

---

谢谢。

在循环中比较

short

对象的最低有效字节与

0xA7

（即

1010 0111

）并在每次循环迭代中将

short

值向右移动一位。

比较

short

对象的最低有效字节与

0xA7

（即，

1010 0111

）在循环中，并在每次循环迭代中将

short

值向右移动一位。

将

short

对象的最低有效字节与

0xA7

（即，

1010 0111

）进行比较在循环中，并在每次循环迭代中将

short

值向右移动一位。

将

short

对象的最低有效字节与

0xA7

进行比较（即

1010 0111

）在循环中，每次循环迭代时，将

short

值向右移位一位。

只需向右移位8次（第9次不使用），然后检查是否相等

#include <stdio.h>

int main(){
    unsigned short data = 0x4a75;
    unsigned char byte = 0xa7;
    int i;

    for(i = 0; i <= 16 - 8; i++){
        if(byte == (unsigned char)data){
            printf("found signature (offset %i)\n", i);
            break;
        }
        data >>= 1;
    }

    return 0;
}

#包括
int main（）{
无符号短数据=0x4a75；
无符号字符字节=0xa7；
int i；
对于（i=0；i>=1；
}
返回0；
}

只需将位右移8次（第9次不使用），然后检查是否相等

#include <stdio.h>

int main(){
    unsigned short data = 0x4a75;
    unsigned char byte = 0xa7;
    int i;

    for(i = 0; i <= 16 - 8; i++){
        if(byte == (unsigned char)data){
            printf("found signature (offset %i)\n", i);
            break;
        }
        data >>= 1;
    }

    return 0;
}

#包括
int main（）{
无符号短数据=0x4a75；
无符号字符字节=0xa7；
int i；
对于（i=0；i>=1；
}
返回0；
}

只需将位右移8次（第9次不使用），然后检查是否相等

#include <stdio.h>

int main(){
    unsigned short data = 0x4a75;
    unsigned char byte = 0xa7;
    int i;

    for(i = 0; i <= 16 - 8; i++){
        if(byte == (unsigned char)data){
            printf("found signature (offset %i)\n", i);
            break;
        }
        data >>= 1;
    }

    return 0;
}

#包括
int main（）{
无符号短数据=0x4a75；
无符号字符字节=0xa7；
int i；
对于（i=0；i>=1；
}
返回0；
}

只需将位右移8次（第9次不使用），然后检查是否相等

#include <stdio.h>

int main(){
    unsigned short data = 0x4a75;
    unsigned char byte = 0xa7;
    int i;

    for(i = 0; i <= 16 - 8; i++){
        if(byte == (unsigned char)data){
            printf("found signature (offset %i)\n", i);
            break;
        }
        data >>= 1;
    }

    return 0;
}

#包括
int main（）{
无符号短数据=0x4a75；
无符号字符字节=0xa7；
int i；
对于（i=0；i>=1；
}
返回0；
}

您也可以使用查找表代替位移位：

const unsigned short signature[3] = {0xA700, 0x0A70, 0x00A7};
const unsigned short mask[3] = {0xFF00, 0x0FF0, 0x00FF};

您可以分析数据，查看它是否在简单的

for

循环中具有签名：

bool signatureFound = false;
int i;

for(i = 0; i < 3; i++)
{
    if((data & mask[i]) == signature[i])
    {
        signatureFound = true;
        break;
    }
}

bool signatureFound=false；
int i；
对于（i=0；i<3；i++）
{
if（（数据和掩码[i]）==签名[i]）
{
signatureFound=true；
打破
}
}

您也可以使用查找表代替位移位：

const unsigned short signature[3] = {0xA700, 0x0A70, 0x00A7};
const unsigned short mask[3] = {0xFF00, 0x0FF0, 0x00FF};

您可以分析数据，查看它是否在简单的

for

循环中具有签名：

bool signatureFound = false;
int i;

for(i = 0; i < 3; i++)
{
    if((data & mask[i]) == signature[i])
    {
        signatureFound = true;
        break;
    }
}

bool signatureFound=false；
int i；
对于（i=0；i<3；i++）
{
if（（数据和掩码[i]）==签名[i]）
{
signatureFound=true；
打破
}
}

您也可以使用查找表代替位移位：

const unsigned short signature[3] = {0xA700, 0x0A70, 0x00A7};
const unsigned short mask[3] = {0xFF00, 0x0FF0, 0x00FF};

您可以分析数据，查看它是否在简单的

for

循环中具有签名：

bool signatureFound = false;
int i;

for(i = 0; i < 3; i++)
{
    if((data & mask[i]) == signature[i])
    {
        signatureFound = true;
        break;
    }
}

bool signatureFound=false；
int i；
对于（i=0；i<3；i++）
{
if（（数据和掩码[i]）==签名[i]）
{
signatureFound=true；
打破
}
}

您也可以使用查找表代替位移位：

const unsigned short signature[3] = {0xA700, 0x0A70, 0x00A7};
const unsigned short mask[3] = {0xFF00, 0x0FF0, 0x00FF};

您可以分析数据，查看它是否在简单的

for

循环中具有签名：

bool signatureFound = false;
int i;

for(i = 0; i < 3; i++)
{
    if((data & mask[i]) == signature[i])
    {
        signatureFound = true;
        break;
    }
}

bool signatureFound=false；
int i；
对于（i=0；i<3；i++）
{
if（（数据和掩码[i]）==签名[i]）
{
signatureFound=true；
打破
}
}

如果你非常渴望速度，一个（仅仅！）8192字节的内存将为你提供一点，以满足每一个可能的值：-）

正如@jxh所建议的，对于256个字节，您可以构造一个表来转移不匹配的位。构造该表需要如下内容：

enum { patt = 0xA7 } ;
int8_t sht[256] ;

for (int i = 0 ; i < 256 ; ++i)
  {
    int8_t  s ;
    uint8_t b, m ;

    b = i ;
    s = 0 ;
    m = 0xFF ;

    while (b != (patt & m))
      {
        b >>= 1 ;
        m >>= 1 ;
        s  += 1 ;
      } ;

    sht[i] = s ;
  } ;

这会累积在0xA7的位置中，但即使您不需要它，它也很有用，因为它会停止循环

对随机值进行一点计时，我发现简单移位方法所需的时间大约是移位表的3倍，大约是位向量查找方法的5.5倍

---

[为了完整性：如果您正在寻找的模式是<0x80，那么您需要更改掩码（当前为

0xFF

）和最大有用移位（当前为

8

）。]

如果您迫切需要速度，那么（仅！）8192字节的内存将为每个可能的值提供一位：-）

正如@jxh所建议的，对于256个字节，您可以构造一个表来转移不匹配的位。构造该表需要如下内容：

enum { patt = 0xA7 } ;
int8_t sht[256] ;

for (int i = 0 ; i < 256 ; ++i)
  {
    int8_t  s ;
    uint8_t b, m ;

    b = i ;
    s = 0 ;
    m = 0xFF ;

    while (b != (patt & m))
      {
        b >>= 1 ;
        m >>= 1 ;
        s  += 1 ;
      } ;

    sht[i] = s ;
  } ;

这会累积在0xA7的位置中，但即使您不需要它，它也很有用，因为它会停止循环

对随机值进行一点计时，我发现简单移位方法所需的时间大约是移位表的3倍，大约是位向量查找方法的5.5倍

---

[为了完整性：如果您正在寻找的模式是<0x80，那么您需要更改掩码（当前为

0xFF

）和最大有用移位（当前为

8

）。]

如果您迫切需要速度，那么（仅！）8192字节的内存将为每个可能的值提供一位：-）

正如@jxh所建议的，对于256个字节，您可以构造一个表来转移不匹配的位。构造该表需要如下内容：

enum { patt = 0xA7 } ;
int8_t sht[256] ;

for (int i = 0 ; i < 256 ; ++i)
  {
    int8_t  s ;
    uint8_t b, m ;

    b = i ;
    s = 0 ;
    m = 0xFF ;

    while (b != (patt & m))
      {
        b >>= 1 ;
        m >>= 1 ;
        s  += 1 ;
      } ;

    sht[i] = s ;
  } ;

这会累积在0xA7的位置中，但即使您不需要它，它也很有用，因为它会停止循环

对随机值进行一点计时，我发现简单移位方法所需的时间大约是移位表的3倍，大约是位向量查找方法的5.5倍

[为了完整性：如果您