比较 C 中的两个二进制文件

Question

我正在编写一个程序来比较两个二进制文件并绘制第一个差异。 我想从每个文件中连续读取 16 个字节的数据并进行比较。 为此，我将两个文件中的 16 个字节存储到char *buffer1, buffer2 。 当我打印输出时，我得到buffer1有file1和file2的数据。

代码如下：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

void printConversion(char *buf1, char *buf2) {
    size_t len = strlen(buf1);
    char *binary = malloc(len * 8 + 1); 
    binary[0] = '\0';
    for (size_t i = 0; i < len; ++i) {
        char ch = buf1[i];
        for (int j = 7; j >= 0; --j) {
            if (ch & (1 << j)) {
                strcat(binary,"1");
            } else {
                strcat(binary,"0");
            }
        }
    }

    printf("File1: %s\t", binary);
    free(binary);
    printf("File2:");
    for (int i = 0; i < sizeof(buf2); i++) {
        printf("%x", buf2[i] - '0');
    }
}

void fileRead(FILE *fp, char *buf, int count) {
    fseek(fp, count, SEEK_SET);    
    fread(buf, 1, 16, fp);
}

int fileSize(FILE *fp) {
    fseek(fp, 0, SEEK_END);
    int size = ftell(fp) + 1;
    return size;
}

int main(int argc, char *argv[]) {
    printf("***Binary File Comparator***\n ");
    int count = 0;
    int index = 0;
    char buffer1[16];
    char buffer2[16];
    char buffer3[16];
    char buffer4[16];

    // Invalid Number of Arguments
    if (argc < 3 || argc > 3) {
        printf("Invalid Number of Arguments\n");
    }

    FILE *fp1, *fp2;
    fp1 = fopen(argv[1], "rb");
    int size = fileSize(fp1);
    int size1 = size;
    fclose(fp1);

    while (size > 1) {
        fp1 = fopen(argv[1], "rb");
        fileRead(fp1, buffer1, count);
        fclose(fp1);

        fp2 = fopen(argv[2], "rb");
        fileRead(fp2, buffer2, count);
        if (size1 < count) {
            int lastSize = count - size1;
            count = count + lastSize;
            fclose(fp2);
        } else {
            count = count+16;
            fclose(fp2);
        }

        **printf("buffer1:%s\tbuffer2:%s\n", buffer1, buffer2)**;
        size = size - 16;

        int result = strcmp(buffer1, buffer2);
        if (result != 0) {
            for (int i = 0; i < sizeof(buffer1); i++) {
                if (buffer1[i] != buffer2[i]) {
                    int count1 = (count - 16) + i;
                    index++;
                    if (index == 1) {
                        printf("Byte_Offset:%x\n", count1);
                        fp1 = fopen(argv[1], "rb");
                        fileRead(fp1, buffer3, count1);
                        fclose(fp1);
                        fp2 = fopen(argv[2], "rb");
                        fileRead(fp2, buffer4, count1);
                        fclose(fp2);
                        printConversion(buffer3, buffer4);
                        break;
                    }
                } else {
                    continue;
                }
            } 
        }
    }
}

我试图突出显示正在打印我的buffer1和buffer2的 printf 部分

输出如下：

 buffer1:83867715933586928386771593358692   buffer2:8386771593358692
buffer1:49216227905963264921622790596326    buffer2:4921622790596326
buffer1:40267236116867294026723611686729    buffer2:4026723611686729
buffer1:82306223673529228230622367352922    buffer2:8230622367352922
buffer1:25869679356114222586967935611422    buffer2:2586967935611422

任何人都可以帮助我做错了什么。 请指出错误以及可以在代码中进行哪些优化更改。 我正处于学习阶段，您的反馈将非常有帮助。

Answer 1

一次读取 16 个字节会使任务复杂化。 如果目标是指示第一个差异，只需使用getc()这种方式一次从两个文件中读取一个字节：

int compare_files(FILE *fp1, FILE *fp2) {
    unsigned long pos;
    int c1, c2;
    for (pos = 0;; pos++) {
        c1 = getc(fp1);
        c2 = getc(fp2);
        if (c1 != c2 || c1 == EOF)
            break;
    }
    if (c1 == c2) {
        printf("files are identical and have %lu bytes\n", pos);
        return 0;  // files are identical
    } else
    if (c1 == EOF) {
        printf("file1 is included in file2, the first %lu bytes are identical\n", pos);
        return 1;
    } else
    if (c2 == EOF) {
        printf("file2 is included in file1, the first %lu bytes are identical\n", pos);
        return 2;
    } else {
        printf("file1 and file2 differ at position %lu: 0x%02X <> 0x%02X\n", pos, c1, c2);
        return 3;
    }
}

在效率方面，如果流被缓冲，一次读取一个字节不会造成问题。 对于大文件，如果目标系统和给定的输入流可用，您可以通过内存映射文件内容来获得更好的性能。

Answer 2

不是一个实际的答案，而是一个关于优化的词。 如果您有更大的缓冲区，您可以提高程序的速度。 基本上，缓冲区越大，程序运行得越快，但是您通过增大缓冲区获得的速度将以对数方式增加。

这是一张图表，可以帮助您理解。 此外，我提到的适用于任何类似的情况。 这包括：复制文件、填充声音缓冲区等。首先将整个文件加载到 RAM 中并对其进行操作通常比加载部分文件更快。 Ofc 这对于较大的文件是不可能的，但如果你想要速度，这仍然是你应该追求的目标。

PS：我写在这里是因为我没有代表发表评论。

编辑：我想出了解决方案，但由于您没有说明需要对buffer3和buffer4做什么，我将其打包在一个函数中。

如果您确定只使用 16 字节作为缓冲区大小，请删除nBufferSize参数并将缓冲区动态分配替换为静态分配。

如果执行后您需要缓冲区，请将它们添加为参数并保留nBufferSize参数。 请记住，如果您打算在函数外使用它们，您也应该在函数外分配它们，以免事情变得混乱。

/** Returns 0 if files are identical, 1 if they are different and -1 if there 
is an error. */
int FileCmp(char* szFile1, char* szFile2, int nBufferSize)
{
    FILE *f1, *f2;
    f1 = fopen(szFile1, "rb");
    f2 = fopen(szFile2, "rb");

    // Some error checking?
    if (f1 == NULL || f2 == NULL)
        return -1;

    // You can check here for file sizes before you start comparing them.
    //  ...

    // Start the comparrison.

    /// Replace this part with static allocation. --------
    char* lpBuffer1 = malloc(sizeof(char)*nBufferSize);
    if (lpBuffer1 == NULL) // close the files and return error.
    {
        fclose(f1);
        fclose(f2);
        return -1;
    }
    char* lpBuffer2 = malloc(sizeof(char)*nBufferSize);
    if (lpBuffer2 == NULL) // close the files, free buffer1 and return error.
    {
        free(lpBuffer1);
        fclose(f1);
        fclose(f2);
        return -1;
    }
    /// --------------------------------------------------

    while(1)
    {
        unsigned int uRead1 = fread(lpBuffer1, sizeof(char), nBufferSize, f1);
        unsigned int uRead2 = fread(lpBuffer2, sizeof(char), nBufferSize, f2);

        if (uRead1 != uRead2)
            goto lFilesAreDifferent;

        for(unsigned int i = 0; i < uRead1; i++)
            if (lpBuffer1[i] != lpBuffer2[i])
                goto lFilesAreDifferent;

        if ((feof(f1) != 0) && (feof(f2) != 0))
            break; // both files have nothing more to read and are identical.

        goto lSkip;

        lFilesAreDifferent:
            free(lpBuffer1);
            free(lpBuffer2);
            fclose(f1);
            fclose(f2);
            return 1;

        lSkip:;
    }

    // The files are the same. Close them, free the buffers and return 0.
    free(lpBuffer1);
    free(lpBuffer2);
    fclose(f1);
    fclose(f2);
    return 0;
}

一个简单的演示：

#define BUFFER_SIZE 16
int main(int nArgs, char** szArgs)
{
    if (nArgs != 3)
    {
        printf("Invalid number of arguments.");
        return 0;
    }

    int nResult = FileCmp(szArgs[1], szArgs[2], BUFFER_SIZE);
    switch (nResult)
    {
        case 0: printf("Files [%s] and [%s] are identical.", szArgs[1], szArgs[2]); break;
        case 1: printf("Files [%s] and [%s] are different.", szArgs[1], szArgs[2]); break;
        case -1: printf("Error."); break;
    }

    return 0;
}

编辑二：就我个人而言，我从未使用过 C 标准 FILE 库（它是 C++ fstream 或纯 win32 fileapi）所以不要把我的话当成理所当然，但fread是我能找到的最快的函数（比fgets或fgetc快）。 如果你想要比这更快，你应该进入依赖于操作系统的函数（比如 Windows 的ReadFile() ）。

Answer 3

chqrlie 使用getc的解决方案绝对是做到这一点的正确方法。 我想解决评论中提出的一些问题，并发现最好用代码来解决。 在一个评论中，我推荐伪代码，它可能会令人困惑（即，由于短路，您不能编写fwrite(file1...) || fwrite(file2 ...) 。但是您可以实现该想法和：

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/*
 * Compare two files, 16 bytes at a time. (Purely to demonstrate memcmp.
 * Clearly, this should be implemented with getc.)
 */

FILE * xfopen(const char *, const char *);
size_t xfread(void *, FILE *, const char *);

int
main(int argc, char **argv)
{
        FILE *fp[2];
        size_t n[2];
        char buf[2][16];
        unsigned count = 0;

        if(argc != 3) { return EXIT_FAILURE; }
        fp[0] = xfopen(argv[1], "r");
        fp[1] = xfopen(argv[2], "r");
        do {
                n[0] = xfread(buf[0], fp[0], argv[1]);
                n[1] = xfread(buf[1], fp[1], argv[2]);
                if( n[0] != n[1] || (n[0] && memcmp(buf[0], buf[1], n[0]))) {
                        fprintf(stderr, "files differ in block %u\n", count);
                        return 1;
                }
                count += 1;
        } while(n[0]);
        puts("files are identical");
        return 0;
}

size_t
xfread(void *b, FILE *fp, const char *name)
{
        size_t n = fread(b, 1, 16, fp);
        if(n == 0 && ferror(fp)) {
                fprintf(stderr, "Error reading %s\n", name);
                exit(EXIT_FAILURE);
        }
        return n;
}

FILE *
xfopen(const char *path, const char *mode)
{
        FILE *fp = strcmp(path, "-") ? fopen(path, mode) : stdin;
        if( fp == NULL ) {
                perror(path);
                exit(EXIT_FAILURE);
        }
        return fp;
}