计算crc16的源代码：
/**************************************
declare const
***************************************/
unsigned short crc16_table[0x10]={
0x1,0x3,0xa5,0x60c6,0x70e7,
0x9,0xa14a,0xb16b,0xc18c,0xd1ad,0xe1ce,0xf1ef,
/*************************************************
crc16_verify
crc16数据校验功能
crc_buff输入数据流，数据流长度length
* 其 它： 此函数是以半个字节为单位进行处理的
***************************************************/
unsigned short
crc16_Verify(unsigned char *crc_buff, unsigned char length)
unsigned short
unsigned char data_
crc_temp = 0xFFFF;
while((length--)!= 0x00)
= crc_temp&&0x0c;
^= crc16_table[data_temp ^ ((*crc_buff)&&4)]; //高4位
= crc_temp&&0x0c;
^= crc16_table[data_temp ^ ((*crc_buff) & 0x0f)]; //低4位
crc_buff ++;
return(crc_temp);
/********************************************************
crc16_Verify_For_Pid
crc16数据校验功能
crc_buff输入数据流，数据流长度length
* 其 它： 此函数并不是对完整的数据字节进行计算，
* 最后多出了1bit，如数据组：buf[0],buf[1],buf[2],buf[3],
* 需要计算crc的是buf[0]-buf[2],与buf[3]的最高位，
* 参数len为整个数组长度，里面进行了处理
********************************************************/
unsigned short
crc16_Verify_For_Pid(unsigned char *crc_buff, unsigned char len)
unsigned short
unsigned char data_
unsigned char i, temp_
temp_length = len-1;
crc_temp = 0
for( i=0; i&temp_ i++ )
= crc_temp&&0x0c;
^= crc16_table[data_temp ^ (crc_buff[i]&&4)]; //高4位
= crc_temp&&0x0c;
^= crc16_table[data_temp ^ (crc_buff[i] & 0x0f)]; //低4位
//下面为对最后1字节的最高位进行CRC计算的处理
if( (crc_temp&0x8000)!=0 )
crc_temp &&= 1;
crc_temp ^= 0x1021;
crc_temp &&= 1;
if( (crc_buff[temp_length]&0x80)!=0 )
crc_temp ^= 0x1021;
return(crc_temp);
//unsigned short crc16_table[256];
/***********************************************
crc16_verify
* 功 能：计算数据流* pData的16位CRC校验码
crc_buff输入数据流，nLength数据流长度
* 输 出： CRC校验值
* 其 它： 此函数是以一个字节为单位进行处理的
************************************************/
/*unsigned short crc16_Verify(unsigned char * pData, unsigned char nLength)
unsigned short crc16 = 0x0000;
while(nLength&0)
crc16 = (crc16 && 8) ^ crc16_table[((crc16&&8) ^ (*pData)) & 0xff]; //crc16_table表由函数get_CrcTable生成
nLength--;
return crc16;
/*****************************************************************************************************
* 函 数：get_CrcTable
* 功 能：生成0－255对应的CRC16校验码
* 输 入：gEnpoly为生成多项式
* 输 出：0-255的CRC校验码
* 其 它：注意，低位先传送时，生成多项式应反转(低位与高位互换)。如CRC16-CCITT为0x1021，反转后为0x8408
****************************************************************************************************/
/*void get_CrcTable(unsigned short gEnpoly)
unsigned short crc16=0;
unsigned short i,j,k;
for( i=0, k=0; i&256; i++,k++ )
crc16 = i&&8;
for( j=8; j&0; j-- )
if( crc16&0x8000 )
//反转时cRc_16&0x0001
crc16 = (crc16&&=1)^gE //反转时cRc_16=(cRc_16&&=1)^gEnpoly
crc16&&=1;
//反转时cRc_16&&=1
crc16_table[k] = crc16;
void get_VersCrcTable(unsigned short gEnpoly)
unsigned short crc16=0;
unsigned short i,j,k;
for( i=0, k=0; i&256; i++,k++ )
for( j=8; j&0; j-- )
if( crc16&0x0001 )
//反转时cRc_16&0x0001
crc16 = (crc16&&=1)^gE //反转时cRc_16=(cRc_16&&=1)^gEnpoly
crc16 &&= 1;
//反转时cRc_16&&=1
crc16_table[k] = crc16;
没有更多推荐了，php中CRC32的用法：
crc32 — 计算一个字符串的 crc32 多项式
生成 string 参数的 32 位循环冗余校验码多项式……：
这句话从英文翻译过来的，不正确，准确的说应该是这么理解：
以32位循环冗余校验多项式算法，来计算一个字符串，返回一个（可能带符号的）整数。
使用方法：
这个函数的功能类似于md5算法、sha1算法加密。这个函数的使用过程中，需要多考虑取返回的整数的绝对值就可以了。
至于如何能做到检查传输的数据是否完整：
参考md5的常见使用场景。
32位循环冗余校验多项式：这个是一个数学算法，在php的源码内可以看到。你可以当作他是一个md5算法的数字版。
经常有人问，说CRC、MD5、SHA1都是计算一个校验值的，到底有何区别
CRC、MD5、SHA1都是通过对数据进行计算，来生成一个校验值，该校验值用来校验数据的完整性。
1. 算法不同。CRC采用多项式除法，MD5和SHA1使用的是替换、轮转等方法；
校验值的长度不同。CRC校验位的长度跟其多项式有关系，一般为16位或32位；MD5是16个字节（128位）；SHA1是20个字节（160位）；
3. 校验值的称呼不同。CRC一般叫做CRC值；MD5和SHA1一般叫做哈希值（Hash）或散列值；
安全性不同。这里的安全性是指检错的能力，即数据的错误能通过校验位检测出来。CRC的安全性跟多项式有很大关系，相对于MD5和SHA1要弱很多；MD5的安全性很高，不过大概在04年的时候被山东大学的王小云破解了；SHA1的安全性最高。
5. 效率不同，CRC的计算效率很高；MD5和SHA1比较慢。
6. 用途不同。CRC一般用作通信数据的校验；MD5和SHA1用于安全（Security）领域，比如文件校验、数字签名等。
CRC校验、MD5、SHA1算法的概念和可靠性现状
【转载】Md5 和 CRC32 的区别
CRC32、MD5、SHA1算法校验介绍
获取文件CRC和MD5
Android中MD5加密方式工具类
没有更多推荐了，VS2015 MFC 编写 常见的CRC校验，CRC4,CRC5,CRC8,CRC16,CRC32等下载
[问题点数：0分]
本版专家分：0
结帖率 48.05%
CSDN今日推荐
匿名用户不能发表回复！
其他相关推荐说明：&&MFC写的输入16进制字符串计算CRC16值的源码(MFC write the input hexadecimal string to calculate the CRC16 value of the source)
文件列表：
CRC16\CRC16\ReadMe.txt
CRC16\CRC16\CRC16.h
CRC16\CRC16\resource.h
CRC16\CRC16\stdafx.h
CRC16\CRC16\targetver.h
CRC16\CRC16\CRC16.cpp
CRC16\CRC16\stdafx.cpp
CRC16\CRC16\CRC16.vcxproj.filters
CRC16\CRC16\CRC16.rc
CRC16\CRC16.sln
CRC16\CRC16.suo
CRC16\CRC16\CRC16.vcxproj.user
CRC16\CRC16\CRC16.vcxproj
CRC16\CRC16
近期下载者：
相关文件：来自：http://www.baiheee.com/Documents/.htm
CRC冗余循环校验，传输的帧或者序列为n位，生成冗余码多项式为2(^k)+...+1，用n左移k位作为被除数，用模2运算(加法进位的舍弃，减法得到的商和减数用模2加法规则得到被减数，其实减法可以用异或运算得到商；CRC中的除法就是首位够则除1不够则除0得到商用模2减法计算即可）被除数除以生成多项式的数，得到余数，将余数放到被除数的n位，得到nk序列数据。将CRC计算后加上冗余数据的数据，发送给接收端。接收端用将接收到的数据作为被除数，用模2运算，除以生成多项式，如果余数是0，那么认为接收到的数据是完整的。
PNG图片中每个Chunk都是由：数据长度+Chunk类型+数据内容+CRC校验码。
CRC(cyclic redundancy check)域中的值是对Chunk Type Code域和Chunk Data域中的数据进行计算得到的。CRC具体算法定义在ISO 3309和ITU-T V.42中，其值按下面的CRC码生成多项式进行计算：
x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1
模2运算得到CRC校验码的。
CRC具体的算法实现，一般是用硬件实现，或者是字节型算法，但是内部的机制仍然是等同于二进制信息序列的，模2运算，除以多项式得到余数的；只不过算法的过程有差异。
模2除法计算CRC实例：
在数据存储和数据通讯领域，CRC无处不在:著名的通讯协议X.25的FCS(帧检错序列)采用的是CRC.CCITT，ARJ、LHA等压缩工具软件采用的是CRC32，磁盘驱动器的读写采用了CRC16，通用的图像存储格式GIF、TIFF等也都用CRC作为检错手段。以太网帧是对所有的帧数据用生成多项式：x32+x26+x23+x22+x16+x12+x11+x10+x8+x7+x5+x4+x2+x+1来进行CRC计算，得到的4字节CRC放到以太网帧的后面。
CRC查表法的C语言代码：# include &stdio.h&
# include &string.h&
// char*,unsigned char*记录的就是二进制转换到的十六进制的字节码[整数原码补码，浮点数IEEE74原码，字符编码原码]。
// char,unsigned char会转换到字符类型; 但是char,unsigned char整数运算还是十六进制的字节码。
// 所以可以提供一个对于十六进制的字节码直接进行CRC计算。
static uint POLYNOMIAL = 0xEDB88320 ;
uint g_CRCTable[256] ;
void init_table()
for (i = 0 ; i & 256 ; i++)
for (j = 0, g_CRCTable[i] = j & 8 ; j++)
g_CRCTable[i] = (g_CRCTable[i]&&1)^((g_CRCTable[i]&1)?POLYNOMIAL:0) ;
uint crc32(uint crc, char *buff, int len)
for (int i = 0; i & i++)
int data = buff[i];
crc = (crc && 8) ^ g_CRCTable[(crc ^ buff[i]) & 0xff];
uint crc32_foruint(uint crc, unsigned int data[], int len)
for (int i = 0; i & i++)
int nData = data[i];
crc = (crc && 8) ^ g_CRCTable[(crc ^ data[i]) & 0xff];
int main ()
// 初始化表
init_table();
char s[] = "aaaaaa";
printf("%08X\n", crc32(0, s, strlen(s)));
unsigned int data[6] = {0x61,0x61,0x61,0x61,0x61,0x61};
//unsigned int arrayData[21] = {/*0x00,0x00,0x00,0x0D,0x49,0x48,0x44,0x52,*/0x00,0x00,0x00,\
// 0xDC,0x00,0x00,0x00,0xDC,0x10,0x06,0x00,0x00,0x00};
printf("%08X\n", crc32_foruint(0, data, 6));
return 0 ;
CRC计算方法与实例
文章编号：
文章分类：
关 键 词：
文章来源：
利用CRC进行检错的过程可简单描述为：在发送端根据要传送的k位二进制码序列，以一定的规则产生一个校验用的r位监督码(CRC码)，附在原始信息后边，构成一个新的二进制码序列数共k+r位，然后发送出去。在接收端...
CRC的全称为Cyclic Redundancy Check，中文名称为循环冗余校验。它是一类重要的线性分组码，编码和解码方法简单，检错和纠错能力强，在通信领域广泛地用于实现差错控制。实际上，除数据通信外，CRC在其它很多领域也是大有用武之地的。例如我们读软盘上的文件，以及解压一个ZIP文件时，偶尔会碰到“Bad CRC”错误，由此它在数据存储方面的应用可略见一斑。
差错控制理论是在代数理论基础上建立起来的。这里我们着眼于介绍CRC的算法与实现，对原理只能捎带说明一下。若需要进一步了解线性码、分组码、循环码、纠错编码等方面的原理，可以阅读有关资料。
利用CRC进行检错的过程可简单描述为：在发送端根据要传送的k位二进制码序列，以一定的规则产生一个校验用的r位监督码(CRC码)，附在原始信息后边，构成一个新的二进制码序列数共k+r位，然后发送出去。在接收端，根据信息码和CRC码之间所遵循的规则进行检验，以确定传送中是否出错。这个规则，在差错控制理论中称为“生成多项式”。
1 代数学的一般性算法
在代数编码理论中，将一个码组表示为一个多项式，码组中各码元当作多项式的系数。例如 1100101 表示为
1·x6+1·x5+0·x4+0·x3+1·x2+0·x+1，即 x6+x5+x2+1。
设编码前的原始信息多项式为P(x)，P(x)的最高幂次加1等于k；生成多项式为G(x)，G(x)的最高幂次等于r；CRC多项式为R(x)；编码后的带CRC的信息多项式为T(x)。
发送方编码方法：将P(x)乘以xr(即对应的二进制码序列左移r位)，再除以G(x)，所得余式即为R(x)。用公式表示为
T(x)=xrP(x)+R(x)
接收方解码方法：将T(x)除以G(x)，如果余数为0，则说明传输中无错误发生，否则说明传输有误。
举例来说，设信息码为1100，生成多项式为1011，即P(x)=x3+x2，G(x)=x3+x+1，计算CRC的过程为
-------- = ---------- = -------- = (x3+x2+x) + --------
即 R(x)=x。注意到G(x)最高幂次r=3，得出CRC为010。
如果用竖式除法，计算过程为
(1100左移3位)
因此，T(x)=(x6+x5)+(x)=x6+x5+x, 即 =1100010
如果传输无误，
------ = --------- = x3+x2+x,
无余式。回头看一下上面的竖式除法，如果被除数是1100010，显然在商第三个1时，就能除尽。
上述推算过程，有助于我们理解CRC的概念。但直接编程来实现上面的算法，不仅繁琐，效率也不高。实际上在工程中不会直接这样去计算和验证CRC。
下表中列出了一些见于标准的CRC资料：
生成多项式
x12+x11+x3+x+1
x16+x12+x2+1
x16+x12+x5+1
ISO HDLC, ITU X.25, V.34/V.41/V.42, PPP-FCS
x32+x26+x23+...+x2+x+1
ZIP, RAR, IEEE 802 LAN/FDDI, IEEE 1394, PPP-FCS
x32+x28+x27+...+x8+x6+1
* 生成多项式的最高幂次项系数是固定的1，故在简记式中，将最高的1统一去掉了，如04C11DB7实际上是104C11DB7。
** 前称CRC-CCITT。ITU的前身是CCITT。
2 硬件电路的实现方法
多项式除法，可用除法电路来实现。除法电路的主体由一组移位寄存器和模2加法器(异或单元)组成。以CRC-ITU为例，它由16级移位寄存器和3个加法器组成，见下图(编码/解码共用)。编码、解码前将各寄存器初始化为"1"，信息位随着时钟移入。当信息位全部输入后，从寄存器组输出CRC结果。
3 比特型算法
上面的CRC-ITU除法电路，完全可以用软件来模拟。定义一个寄存器组，初始化为全"1"。依照电路图，每输入一个信息位，相当于一个时钟脉冲到来，从高到低依次移位。移位前信息位与bit0相加产生临时位，其中bit15移入临时位，bit10、bit3还要加上临时位。当全部信息位输入完成后，从寄存器组取出它们的值，这就是CRC码。
typedef unsigned char
typedef unsigned char
typedef unsigned short u16;
typedef union {
u16 bit0 : 1;
u16 bit1 : 1;
u16 bit2 : 1;
u16 bit3 : 1;
u16 bit4 : 1;
u16 bit5 : 1;
u16 bit6 : 1;
u16 bit7 : 1;
u16 bit8 : 1;
u16 bit9 : 1;
u16 bit10 : 1;
u16 bit11 : 1;
u16 bit12 : 1;
u16 bit13 : 1;
u16 bit14 : 1;
u16 bit15 : 1;
} CRCREGS;
void crcInitRegisters()
regs.val = 0
void crcInputBit(bit in)
a = regs.bits.bit0 ^
regs.bits.bit0 = regs.bits.bit1;
regs.bits.bit1 = regs.bits.bit2;
regs.bits.bit2 = regs.bits.bit3;
regs.bits.bit3 = regs.bits.bit4 ^
regs.bits.bit4 = regs.bits.bit5;
regs.bits.bit5 = regs.bits.bit6;
regs.bits.bit6 = regs.bits.bit7;
regs.bits.bit7 = regs.bits.bit8;
regs.bits.bit8 = regs.bits.bit9;
regs.bits.bit9 = regs.bits.bit10;
regs.bits.bit10 = regs.bits.bit11 ^
regs.bits.bit11 = regs.bits.bit12;
regs.bits.bit12 = regs.bits.bit13;
regs.bits.bit13 = regs.bits.bit14;
regs.bits.bit14 = regs.bits.bit15;
regs.bits.bit15 =
u16 crcGetRegisters()
return regs.
void crcInputBit(bit in)
a = regs.bits.bit0 ^
regs.val &&= 1;
if(a) regs.val ^= 0x8408;
细心的话，可以发现0x1(CRC-ITU的简记式)之间的关系。由于我们是从低到高输出比特流的，将0x1021左右反转就得到0x8408。将生成多项式写成 G(x)=1+x5+x12+x16，是不是更好看一点？
下面是一个典型的PPP帧。最后两个字节称为FCS(Frame Check Sequence)，是前面11个字节的CRC。
FF 03 C0 21 04 03 00 07 0D 03 06 D0 3A
我们来计算这个PPP帧的CRC，并验证它。
byte ppp[13] = {0xFF, 0x03, 0xC0, 0x21, 0x04, 0x03, 0x00, 0x07, 0x0D, 0x03, 0x06, 0x00, 0x00};
crcInitRegisters();
for(i = 0; i & 11; i++)
for(j = 0; j & 8; j++)
crcInputBit((ppp[i] && j) & 1);
result = ~crcGetRegisters();
ppp[11] = result & 0
ppp[12] = (result && 8) & 0
crcInitRegisters();
for(i = 0; i & 13; i++)
for(j = 0; j & 8; j++)
crcInputBit((ppp[i] && j) & 1);
result = crcGetRegisters();
可以看到，计算出的CRC等于0x3AD0，与原来的FCS相同。验证结果等于0。初始化为全"1"，以及将寄存器组的值求反得到CRC，都是CRC-ITU的要求。事实上，不管初始化为全"1"还是全"0"，计算CRC取反还是不取反，得到的验证结果都是0。
4 字节型算法
比特型算法逐位进行运算，效率比较低，不适用于高速通信的场合。数字通信系统(各种通信标准)一般是对一帧数据进行CRC校验，而字节是帧的基本单位。最常用的是一种按字节查表的快速算法。该算法基于这样一个事实：计算本字节后的CRC码，等于上一字节余式CRC码的低8位左移8位，加上上一字节CRC右移 8位和本字节之和后所求得的CRC码。如果我们把8位二进制序列数的CRC(共256个)全部计算出来，放在一个表里，编码时只要从表中查找对应的值进行处理即可。
CRC-ITU的计算算法如下：
a.寄存器组初始化为全"1"(0xFFFF)。
b.寄存器组向右移动一个字节。
c.刚移出的那个字节与数据字节进行异或运算，得出一个指向值表的索引。
d.索引所指的表值与寄存器组做异或运算。
f.数据指针加1，如果数据没有全部处理完，则重复步骤b。
g.寄存器组取反，得到CRC，附加在数据之后。
CRC-ITU的验证算法如下：
a.寄存器组初始化为全"1"(0xFFFF)。
b.寄存器组向右移动一个字节。
c.刚移出的那个字节与数据字节进行异或运算，得出一个指向值表的索引。
d.索引所指的表值与寄存器组做异或运算。
e.数据指针加1，如果数据没有全部处理完，则重复步骤b (数据包括CRC的两个字节)。
f.寄存器组的值是否等于“Magic Value”(0xF0B8)，若相等则通过，否则失败。
下面是通用的CRC-ITU查找表以及计算和验证CRC的C语言程序：
const u16 crctab16[] =
0x9, 0xb, 0xad, 0xbf,
0x8c48, 0x9dc1, 0xaf5a, 0xbed3, 0xca6c, 0xdbe5, 0xe97e, 0xf8f7,
0x8, 0xa, 0x56a5, 0x472c, 0x75b7, 0x643e,
0x9cc9, 0x8d40, 0xbfdb, 0xae52, 0xdaed, 0xcb64, 0xf9ff, 0xe876,
0xb, 0x9, 0xaf, 0xbd,
0xad4a, 0xbcc3, 0x8e58, 0x9fd1, 0xeb6e, 0xfae7, 0xc87c, 0xd9f5,
0xa, 0x8, 0x77a7, 0x662e, 0x54b5, 0x453c,
0xbdcb, 0xac42, 0x9ed9, 0x8f50, 0xfbef, 0xea66, 0xd8fd, 0xc974,
0xd, 0xf, 0xa9, 0xbb,
0xce4c, 0xdfc5, 0xed5e, 0xfcd7, 0xe1, 0xab7a, 0xbaf3,
0xc, 0xe, 0x14a1, 0xb3, 0x263a,
0xdecd, 0xcf44, 0xfddf, 0xec56, 0x98e9, 0x8960, 0xbbfb, 0xaa72,
0xf, 0xd, 0xab, 0xb9,
0xef4e, 0xfec7, 0xcc5c, 0xddd5, 0xa96a, 0xb8e3, 0x8a78, 0x9bf1,
0xe, 0xc, 0x35a3, 0x242a, 0x16b1, 0x0738,
0xffcf, 0xee46, 0xdcdd, 0xcd54, 0xb9eb, 0xa862, 0x9af9, 0x8b70,
0x1, 0xa71a, 0xb693, 0xc22c, 0xd3a5, 0xe13e, 0xf0b7,
0xc9, 0x2b52, 0x3adb, 0x4e64, 0x5fed, 0x6d76, 0x7cff,
0x0, 0xb79b, 0xa612, 0xd2ad, 0xc324, 0xf1bf, 0xe036,
0x18c1, 0xbd3, 0x2a5a, 0x5ee5, 0x4f6c, 0x7df7, 0x6c7e,
0xa50a, 0xb483, 0x1, 0xe32e, 0xf2a7, 0xc03c, 0xd1b5,
0xcb, 0x0a50, 0x1bd9, 0x6f66, 0x7eef, 0x4c74, 0x5dfd,
0xb58b, 0xa402, 0x0, 0xf3af, 0xe226, 0xd0bd, 0xc134,
0x39c3, 0x284a, 0x1ad1, 0x0b58, 0x7fe7, 0x6e6e, 0x5cf5, 0x4d7c,
0xc60c, 0xd785, 0xe51e, 0xf497, 0xa1, 0xa33a, 0xb2b3,
0x4a44, 0x5bcd, 0xdf, 0x0c60, 0x1de9, 0x2f72, 0x3efb,
0xd68d, 0xc704, 0xf59f, 0xe416, 0x90a9, 0xbb, 0xa232,
0x5ac5, 0x4b4c, 0x79d7, 0x685e, 0x1ce1, 0x0d68, 0x3ff3, 0x2e7a,
0xe70e, 0xf687, 0xc41c, 0xd595, 0xa12a, 0xb0a3, 0xb1,
0x6b46, 0x7acf, 0xdd, 0x2d62, 0x3ceb, 0x0e70, 0x1ff9,
0xf78f, 0xe606, 0xd49d, 0xc514, 0xb1ab, 0xa022, 0x92b9, 0x8330,
0x7bc7, 0x6a4e, 0x58d5, 0x495c, 0x3de3, 0x2c6a, 0x1ef1, 0x0f78,
u16 GetCrc16(const byte* pData, int nLength)
u16 fcs = 0
while(nLength&0)
fcs = (fcs && 8) ^ crctab16[(fcs ^ *pData) & 0xff];
nLength--;
bool IsCrc16Good(const byte* pData, int nLength)
u16 fcs = 0
while(nLength&0)
fcs = (fcs && 8) ^ crctab16[(fcs ^ *pData) & 0xff];
nLength--;
return (fcs == 0xf0b8);
使用字节型算法，前面出现的PPP帧FCS计算和验证过程，可用下面的程序片断实现：
byte ppp[13] = {0xFF, 0x03, 0xC0, 0x21, 0x04, 0x03, 0x00, 0x07, 0x0D, 0x03, 0x06, 0x00, 0x00};
result = GetCrc16(ppp, 11);
ppp[11] = result & 0
ppp[12] = (result && 8) & 0
if(IsCrc16Good(ppp, 13))
该例中数据长度为11，说明CRC计算并不要求数据2字节或4字节对齐。
至于查找表的生成算法，以及CRC-32等其它CRC的算法，可参考RFC 1661, RFC 3309等文档。需要注意的是，虽然CRC算法的本质是一样的，但不同的协议、标准所规定的初始化、移位次序、验证方法等可能有所差别。
CRC是现代通信领域的重要技术之一。掌握CRC的算法与实现方法，在通信系统的设计、通信协议的分析以及软件保护等诸多方面，能发挥很大的作用。如在作者曾经设计的一个多串口数据传输系统中，每串口速率为460kbps，不加校验时误码率大于10-6，加上简单的奇偶校验后性能改善不很明显，利用CRC进行检错重传，误码率降低至10-15以下，满足了实际应用的要求。
1. Simpson, W., Editor, "The Point-to-Point Protocol (PPP)", STD 51, RFC
2. J. Stone, "Stream Control Transmission Protocol (SCTP) Checksum Change", RFC
3. J. Satran, "Internet Protocol Small Computer System Interface (iSCSI) Cyclic Redundancy Check (CRC)/Checksum Considerations", RFC
4. International Standardization,"High-level data link control (HDLC) procedures", ISO/IEC
5. ITU-T V.41, "Code-independent error-control system", 1989
6. 郭梯云等,《数据传输(修订本)》, 人民邮电出版社, 1998　
CRC算法（直接计算法和查表法）
CRC校验算法
循环冗余校验码计算CRC
如何计算CRC校验码（循环冗余检验码）
CRC码计算及校验原理的最通俗诠释
循环冗余校验（CRC）算法入门引导
crc 校验码的计算方法 （转载）
没有更多推荐了，