CRC算法实现

Question

I'm implementing an CRC16 algorithm in C which is:

init = 0x0000 as long as the data stream goes on if the first bit of data is not equal to the first bit of initial value init = leftshift init once and xor it with the polynomial otherwise leftshift init go to the next data bit init = CRC Checksum

Now the problem is... If I change the init value after the first comparison it's gonna always be equal to the data stream.

For example: If I get the initial value to be

1011 0000 1011 0101

and the data stream

0011 0110 1000 0101

after first iteration.

They are going to always be equal, since the 0's at the beginning do not matter, and can be ignored.

And after the next iteration they are going to be:

011 0000 1011 0101

and data stream respectively

011 0110 1000 0101

but again the 0's can be ignored and we get equality.

I'm really confused.

Here's my C code:

#define POLY 0x8005

int crc = 0x0000;   // Initial value
char data[1024];
int *dp = data;
int fd, nread;

fd = open(argv[1], O_RDWR);
nread = read(fd, data, sizeof(data));
int *end = dp + nread;



while(data < end)
{
    crc = crc & 1 && data & 1 ? crc << 1 : (crc << 1) ^ POLY;
    data++;
}

Answer 1

Several issues:

1. You're operating on the least significant bit but should be working on the most significant bit. This may be what's causing your confusion regarding bits staying the same, since you're looking at the wrong end of the values.

2. crc & 1 && data & 1 checks that the bits are equal to 1 instead of checking that they are equal to each other.

3. You seem to be confused on whether data is an array (as declared), an integer (as used in data & 1 ), or a pointer (as used in data++ ).

4. If you change data to a pointer and increment it by 1 at each step, that would mean that you are only processing one bit from each input byte. You need an inner loop to process all 8 bits.