C++ 如何在linux中对文件执行按位操作？

我想在Linux中对文件执行一些位操作（例如xor两个文件），但我不知道如何才能做到这一点。有没有命令

任何帮助都将不胜感激。

您可以使用映射文件，对映射的内存应用位操作，然后关闭它

或者，将块读入缓冲区，对缓冲区应用操作，然后写出缓冲区也可以

这里有一个例子（C，不是C++），因为所有的错误处理都是相同的，它反转所有位：

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
int main(int argc, char* argv[]) {
    if (argc != 2) {printf("Usage: %s file\n", argv[0]); exit(1);}

    int fd = open(argv[1], O_RDWR);
    if (fd == -1) {perror("Error opening file for writing"); exit(2);}

    struct stat st;
    if (fstat(fd, &st) == -1) {perror("Can't determine file size"); exit(3);}

    char* file = mmap(NULL, st.st_size, PROT_READ | PROT_WRITE,
                      MAP_SHARED, fd, 0);
    if (file == MAP_FAILED) {
        perror("Can't map file");
        exit(4);
    }

    for (ssize_t i = 0;i < st.st_size;i++) {
        /* Binary operation goes here.
        If speed is an issue, you may want to do it on a 32 or 64 bit value at
        once, and handle any remaining bytes in special code. */
        file[i] = ~file[i];
    }

    munmap(file, st.st_size);
    close(fd);
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）{
如果（argc！=2）{printf（“用法：%s文件\n”，argv[0]）；退出（1）；}
int fd=打开（argv[1]，O_RDWR）；
如果（fd=-1）{perror（“打开文件写入时出错”）；退出（2）；}
结构统计；
如果（fstat（fd，&st）=-1）{perror（“无法确定文件大小”）；退出（3）；}
char*file=mmap（NULL，st.st_size，PROT_READ，PROT_WRITE，
MAP_共享，fd，0）；
if（file==MAP_失败）{
perror（“无法映射文件”）；
出口（4）；
}
对于（ssize_t i=0；i

一个快速的互联网搜索显示，一个专用的开源程序，用于XORing两个文件。我之所以找到它，是因为我在博客上写过它，其目的似乎具有法律性质。

多亏了“phihag”，这段代码用于对2个文件执行二进制操作。
例1：您有两个文件，并且想要比较这两个文件，所以对它们执行二进制异或
例2：您使用jdownloader或类似工具下载了一个文件，并将未完成的下载移动到另一个文件夹，然后下载管理器继续未完成的部分并创建另一个文件。因此，您有两个seprate文件，它们可以相互完成。现在，如果对这两个文件执行二进制或二进制运算，则会得到一个完整的文件。

警告：较大的文件将被操作结果覆盖。

#include <unistd.h>
#include <stdlib.h>
#include <stdio.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <string.h>

int main(int argc, char* argv[])
{
    int FP1 = 0, FP2 = 0;
    struct stat St1, St2;
    char *File1 = NULL, *File2 = NULL;
    int Rn = 0;

    if (argc != 4)
    {
        printf("Usage: %s File1 File2 Operator\n", argv[0]);
        exit(1);
    }

    //Opening and mapping File1
    FP1 = open(argv[1], O_RDWR);
    if (FP1 == -1)
    {
        perror("Error opening file1 for writing");
        exit(2);
    }

    if (fstat(FP1, &St1) == -1)
    {
        perror("Can't determine file1 size");
        exit(3);
    }

    File1 = (char*) mmap(NULL, St1.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, FP1, 0);
    if (File1 == MAP_FAILED)
    {
        perror("Can't map file1");
        exit(4);
    }
    //======================

    //Opening and mapping File2
    FP2 = open(argv[2], O_RDWR);
    if (FP2 == -1)
    {
        perror("Error opening file2 for writing");
        exit(2);
    }

    if (fstat(FP2, &St2) == -1)
    {
        perror("Can't determine file2 size");
        exit(3);
    }

    File2 = (char*) mmap(NULL, St2.st_size, PROT_READ | PROT_WRITE, MAP_SHARED, FP2, 0);
    if (File2 == MAP_FAILED)
    {
        perror("Can't map file2");
        exit(4);
    }
    //======================

    //Binary operations
    ssize_t i = 0;
    switch (*(argv[3]))
    {
        case '|':
            if (St1.st_size <= St2.st_size)
                for (i = 0; i < St1.st_size; i ++)
                    File2[i] = File1[i] | File2[i];
            else
                for (i = 0; i < St2.st_size; i ++)
                    File1[i] = File1[i] | File2[i];
            break;
        case '&':
            if (St1.st_size <= St2.st_size)
                for (i = 0; i < St1.st_size; i ++)
                    File2[i] = File1[i] & File2[i];
            else
                for (i = 0; i < St2.st_size; i ++)
                    File1[i] = File1[i] & File2[i];
            break;
        case '^':
            if (St1.st_size <= St2.st_size)
                for (i = 0; i < St1.st_size; i ++)
                    File2[i] = File1[i] ^ File2[i];
            else
                for (i = 0; i < St2.st_size; i ++)
                    File1[i] = File1[i] ^ File2[i];
            break;
        default:
            perror("Unknown binary operator");
            exit(5);
    }
    //======================

    munmap(File1, St1.st_size);
    munmap(File2, St2.st_size);
    close(FP1);
    close(FP2);

    //Renaming the changed file and make output
    char Buffer[1024];
    if (St1.st_size <= St2.st_size)
    {
        Rn = system(strcat(strcat(strcat(strcat(strcpy(Buffer, "mv \""), argv[2]), "\" \""), argv[2]),"-Mapped\""));
        if (Rn == -1)
        {
            perror("Unable to rename the new file.");
            exit(6);
        }
        else
            printf("%s is mapped.\n", argv[2]);
    }
    else
    {
        Rn = system(strcat(strcat(strcat(strcat(strcpy(Buffer, "mv \""), argv[1]), "\" \""), argv[1]),"-Mapped\""));
        if (Rn == -1)
        {
            perror("Unable to rename the new file.");
            exit(6);
        }
        else
            printf("%s is mapped.\n", argv[1]);
    }
    //======================

    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
int main（int argc，char*argv[]）
{
int FP1=0，FP2=0；
结构统计St1、St2；
char*File1=NULL，*File2=NULL；
int Rn=0；
如果（argc！=4）
{
printf（“用法：%s File1 File2 Operator\n”，argv[0]）；
出口（1）；
}
//打开并映射文件1
FP1=打开（argv[1]，O_RDWR）；
如果（FP1==-1）
{
perror（“打开文件1进行写入时出错”）；
出口（2）；
}
如果（fstat（FP1和St1）=-1）
{
perror（“无法确定文件1大小”）；
出口（3）；
}
File1=（char*）mmap（NULL，St1.st_size，PROT_READ | PROT_WRITE，MAP_SHARED，FP1，0）；
if（File1==MAP_失败）
{
perror（“无法映射文件1”）；
出口（4）；
}
//======================
//打开并映射文件2
FP2=打开（argv[2]，O_RDWR）；
如果（FP2==-1）
{
perror（“打开文件2进行写入时出错”）；
出口（2）；
}
如果（fstat（FP2和St2）=-1）
{
perror（“无法确定文件2大小”）；
出口（3）；
}
File2=（char*）mmap（NULL，St2.st_size，PROT_READ | PROT_WRITE，MAP_SHARED，FP2，0）；
if（File2==MAP_失败）
{
perror（“无法映射文件2”）；
出口（4）；
}
//======================
//二进制运算
ssize_t i=0；
开关（*（argv[3]））
{
案例“|”：
如果（St1.st_size你承诺接受答案吗？读chunk，对chunk中的所有数据应用运算符，写chunk@unkulunkulu@phihag是的，我当然不知道，我现在才找到，谢谢；）非常感谢你的回答。你介意再解释一下第一个解决方案吗？@Sina我添加了一个示例程序（我不相信我的C++技巧，所以我在C中写了它，你可能想C++处理错误处理。这有帮助吗？非常感谢，非常有用：）@新浪首先，计算你有多少条目（<代码> num＝ST.Stsith/SsieOf（条目）< /C> >，其中<代码>条目< /C> > <代码>.Cast
file
指向所需类型的指针，并在for循环中将
st.st\u size
替换为
num
。不要忘记处理剩余的
st.st\u size-num*sizeof（条目）
bytes！@Sina您可以使用它将十六进制字符串参数转换为数字。在不完全重写文件头的情况下写入文件头是非常困难的。您可以。