Cum de a calcula suma de control pentru fișierul

Și este posibil mai în detaliu?

modulo 256 = x mod 256

Îmi pare rău, eu nu înțeleg cum să facă acest lucru, puteți cod?

Modulo 256 în acest concurs este de a ignora transferul, puteți desigur că nu, ci pur și simplu utilizarea mai eficientă a bytes și eroare de depășire de blokrovat. Deși operația în sine nu ia mult timp, dar poate fi realizată pe seturi mari de date

Pot să întreb ce este algoritmul CRC?

Este posibil, se reduce codul de eroare (în traducere), pe baza unui algoritm mai complex decât însumarea octeti, un membru existent al unui număr mare de astfel de algoritmi, un număr de ele standard recunoscut.
Se poate ajunge la punctul în care doriți să faceți, de ce și cum besprdmetno.
Dar întrebarea care le-ați primit răspunsul pentru o lungă perioadă de timp, se adaugă toți biții modulului 256, la sfârșitul obțineți suma de control.

CRC algoritm este o metodă de calcul a datelor semnăturii (CRC), care permite o anumită probabilitate de a determina acuratețea datelor la posibilele distorsiuni în timpul transmiterii, depozitării.

Trebuie să fac următoarele: o modificare a codului meu de program, dacă editarea directă a codului sau scrierea programului de patch-uri a fost verificarea codului de schimbare, iar dacă sa întâmplat pur și simplu întrerupe programul meu înainte de începerea programului.

P.S. în cazul în care mai reticenți să răspundă, atunci voi încerca să găsească un răspuns pe undeva.

Eugene_post (23.10.02 21:47)
Protejarea o chestiune delicată, vă deranjează că va face un test de muscatura fără a înțelege cum și ceea ce crezi. Dar, în orice caz, CRC eficient decât CS

const
CrcPolynominal = $ 04C11DB7;

// *******************************
// * Se calculează crc32 cu tampon *
// *******************************
functioneaza BufToCrc (const Buf; Count: Integer). longint;
var
I. Integer;
începe
Rezultat: = $ FFFFFFFF;
pentru I: = 0 la Count - 1 nu începe
Rezultat: = crc32 (Byte (TByteArray (Buf) [I]), rezultat);
se încheie;
se încheie;

// *******************************
// * Se calculează crc32 cu șir de caractere *
// *******************************
funcționa StrToCrc (Valoare: string). longint;
var
I. Integer;
începe
Rezultat: = $ FFFFFFFF;
pentru I: = 1 până la Lungime (Valoare) nu începe
Rezultat: = crc32 (Byte (valoare [I]), Rezultat);
se încheie;
se încheie;

Pentru electronica (asamblare) - este posibil să ne imaginăm un registru de deplasare cu robinete de biți necesari (la grade X), precum și toate robinetele și secvența de un bit de intrare adăugată prin „modulo-2“ și bitul de inserție de biți într-un registru.
După trecerea prin numărul total într-un registru și va fi semnătura (CRC).
Această metodă de extrapolate la o procesare multi-bit.

Pentru a accelera calculul tehnicilor de masă sunt folosite efectiv.

De altfel, aceleași polinoame ireductibile sunt folosite pentru generarea de numere pseudo-aleatoare.

> Eugene_post
O altă realizare

const
CrcSeed = $ ffffffff;

funcționa crc32 (Buffer pointer; .. const BufLen DWord;. crc DWord). DWORD; de asamblare;
asm
împinge edi
mov SED, EAX
mov EAX, ECx
mov ECx, EDX
și ECx, ECx
JZ @Exit
și SED, edi
JZ @Exit
@ Porniți:
XOR EDX, EDX
mov dl, al
SHR EAX, 8
xor dl, [edi]
xor EAX, dword ptr [4 * EDX + crctable32]
inc edi
bucla @ Porniți
@Exit:
pop edi
se încheie;

Funcția CrcStream (Stream. TStream). DWORD;
var
P. Pointer;
C. LongInt;
începe
Rezultat: = CrcSeed;
GetMem (P, 8192);
încerca
Stream.Position: = 0;
în timp ce Stream.Position C: = Stream.Read (P ^, 8192);
Rezultat: = crc32 (P, C, Rezultat)
capăt
în cele din urmă
FreeMem (P, 8192)
se încheie;
Rezultat: = Rezultat xor CrcSeed
se încheie;

Funcția CrcFile (const FileName. string). DWORD;
var
Stream. TFileStream;
începe
Stream: = TFileStream.Create (NumeFișier, fmOpenRead + fmShareDenyNone);
încerca
Rezultat: = CrcStream (Stream)
în cele din urmă
Stream.Free
capăt
se încheie;

Versiunea mesei este mai bine pentru a traduce pe deplin Pascal algoritmică perevedesh nu atât de ușor

Da, este metoda de tabel cu polinomului generator

FUNCȚIA UpdC32 (octetul: BYTE; crc: LONGINT). LONGINT;
BEGIN
UpdC32: = crctabdu32 [BYTE (crc XOR LONGINT (octetul))] XOR ((crc SHR 8) ȘI $ 00FFFFFF)
END;

const
CRC32_POLYNOMIAL = $ EDB88320;

var
Ccitt32Table. array [0..255] de longint;

Funcția crc32 (longint crc; .. const c byte). longint;
începe
crc32: = (((crc SHR 8) și $ 00FFFFFF) xor (Ccitt32Table [(crc xor c) și $ FF]));
se încheie;

Procedura BuildCRCTable;
var
i, j, valoarea. DWORD;
începe
pentru i: = 0-255 do
începe
Valoarea: = i;
pentru j: = 1 do 8 downto
începe
if ((valoare și 1) <> 0), atunci
Valoarea: = (valoarea SHR 1) CRC32_POLYNOMIAL xor
altfel
Valoarea: = valoarea SHR 1;
se încheie;
Ccitt32Table [i]: = valoarea;
capăt
se încheie;

Aceasta este, de asemenea, o metodă de masă, numai masa se calculează, nu sunt stocate.

ROL AL, 1
RCL EDX, 1
JNC @ 2

Aceasta folosește steagul transporta, iar Pascal nu are acces. Dar totul depinde de obiectivele, eu doar nu-mi place este utilizarea de comenzi de asamblare, nu toleranță, cum ar fi tehnologia .NET