Сравнить содержимое файлов между собой, и если оно совпадает, то вывести на экран имена этих файлов

#include <cstdio>
#include <cstdlib>
#include <cstring>
 
inline bool check_open(FILE* file)
{
    if (!file) 
    {
        printf("Error opening file!\n");
        getchar();
        return false;
    }
    return true;
}
 
inline bool check_memory_alloc(char* buffer)
{
    if (!buffer) 
    {
        printf("The memory allocation error!\n");
        getchar();
        return false;
    }
    return true;
}
 
int main()
{ 
    const int N = 3;
    const int M = 2;
    const char* name_f1[N] = {"file1.txt", "file2.txt", "file3.txt"};
    const char* name_f2[M] = {"file4.txt", "file5.txt"};
    
    for (int i = 0; i < N; ++i)
    {
        FILE *file1 = fopen(name_f1[i], "rb"); 
        if (!check_open(file1))
            return 0;
        
        fseek(file1, 0, SEEK_END); 
        int size_f1 = ftell(file1);
        rewind(file1);
        
        char* buffer1 = NULL;
        for (int j = 0; j < M; ++j)
        {
            FILE* file2 = fopen(name_f2[j], "rb");
            if (!check_open(file2))
                return 0;
             
            fseek(file2, 0, SEEK_END); 
            int size_f2 = ftell(file2);
            
            if (size_f1 != size_f2)
            {
                fclose(file2);
                continue;
            }
            
            if (!buffer1)
            {
                buffer1 = (char*) malloc(size_f1);
                if (!check_memory_alloc(buffer1))
                    return 0;
                
                fread(buffer1, 1, size_f1, file1);
            }
            
            char* buffer2 = (char*) malloc(size_f2);
            if (!check_memory_alloc(buffer2))
                    return 0;
            
            rewind(file2);
            fread(buffer2, 1, size_f2, file2);
            
            if (memcmp(buffer1, buffer2, size_f1) != 0)
            {
                free(buffer2);
                fclose(file2);
                continue;
            }
            
            printf("%s%s%s\n", name_f1[i], " equal ", name_f2[j]);
            
            free(buffer2);
            fclose(file2);
        }
        free(buffer1);
        fclose(file1);
    }
    
    printf("Done! Press any key...");
    getchar();
    return 0;
}

#include <cstdio>
#include <cstdlib>
#include <cstring>
 
inline bool check_open(FILE* file)
{
    if (!file) 
    {
        printf("Error opening file!\n");
        getchar();
        return false;
    }
    return true;
}
 
inline bool check_memory_alloc(char* buffer)
{
    if (!buffer) 
    {
        printf("The memory allocation error!\n");
        getchar();
        return false;
    }
    return true;
}
 
int main()
{ 
    const int N = 3;
    const int M = 2;
    const char* name_f1[N] = {"file1.txt", "file2.txt", "file3.txt"};
    const char* name_f2[M] = {"file4.txt", "file5.txt"};
   
    int block;
    
    for (int i = 0; i < N; ++i)
    {
        FILE *file1 = fopen(name_f1[i], "rb"); 
        if (!check_open(file1))
            return 0;
        
        fseek(file1, 0, SEEK_END); 
        int size_f1 = ftell(file1);
        rewind(file1);
        
        char* buffer1 = NULL;
        for (int j = 0; j < M; ++j)
        {
            FILE* file2 = fopen(name_f2[j], "rb");
            if (!check_open(file2))
                return 0;
             
            fseek(file2, 0, SEEK_END); 
            int size_f2 = ftell(file2);
            
            if (size_f1 != size_f2)
            {
                fclose(file2);
                continue;
            }
            rewind(file2);
 
            block = size_f1 / 1000;
            if (block < 50)
                block = size_f1;
           
            buffer1 = (char*) malloc(block);
            if (!check_memory_alloc(buffer1))
                return 0;
                
            char* buffer2 = (char*) malloc(block);
            if (!check_memory_alloc(buffer2))
                    return 0;
            
            bool flag = true;
            while (fread(buffer1, block, 1, file1))
            {
                fread(buffer2, block, 1, file2);
                
                if (memcmp(buffer1, buffer2, block) != 0)
                {
                    free(buffer2);
                    free(buffer1);
                    fclose(file2);
                    rewind(file1);
                    flag = false;
                    break;
                }
            }
            if (!flag)
                continue;
 
            printf("%s%s%s\n", name_f1[i], " equal ", name_f2[j]);
            
            free(buffer2);
            fclose(file2);
            free(buffer1);
            rewind(file1);
        }
        fclose(file1);
    }
    
    printf("Done! Press any key...");
    getchar();
    return 0;
}

#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include <ctime>
 
inline bool check_open(FILE* file)
{
    if (!file) 
    {
        printf("Error opening file!\n");
        getchar();
        return false;
    }
    return true;
}
 
inline bool check_memory_alloc(char* buffer)
{
    if (!buffer) 
    {
        printf("The memory allocation error!\n");
        getchar();
        return false;
    }
    return true;
}
 
int main()
{ 
    const int N = 3;
    const int M = 3;
    const char* name_f1[N] = {"file1.txt", "file1.txt", "file3.txt"};
    const char* name_f2[M] = {"file4.txt", "file5.txt", "file4.txt"};
    
    const int SIZE_BLOCK = 1024 * 128;
    int block;// = 1024 * 128;
 
clock_t t1 = clock();
    
for (int i = 0; i < N; ++i)
    {
        FILE *file1 = fopen(name_f1[i], "rb"); 
        if (!check_open(file1))
            return 0;
        
        fseek(file1, 0, SEEK_END); 
        int size_f1 = ftell(file1);
        rewind(file1);
        
        if (size_f1 < SIZE_BLOCK) // задание размера блока
            block = size_f1;
        else
            block = SIZE_BLOCK;
        
        char* buffer1 = NULL;
        for (int j = 0; j < M; ++j)
        {
            FILE* file2 = fopen(name_f2[j], "rb");
            if (!check_open(file2))
                return 0;
             
            fseek(file2, 0, SEEK_END); 
            int size_f2 = ftell(file2);
            
            if (size_f1 != size_f2)
            {
                fclose(file2);
                continue;
            }
            rewind(file2);
            
            buffer1 = (char*) malloc(block);
            if (!check_memory_alloc(buffer1))
                return 0;
                
            char* buffer2 = (char*) malloc(block);
            if (!check_memory_alloc(buffer2))
                    return 0;
            
            bool flag = true;
            while (fread(buffer1, block, 1, file1))
            {
                fread(buffer2, block, 1, file2);
                
                if (memcmp(buffer1, buffer2, block) != 0)
                {
                    free(buffer2);
                    free(buffer1);
                    fclose(file2);
                    rewind(file1);
                    flag = false;
                    break;
                }
            }
            if (!flag)
                continue;
 
            printf("%s%s%s\n", name_f1[i], " equal ", name_f2[j]);
            
            free(buffer2);
            fclose(file2);
            free(buffer1);
            rewind(file1);
        }
        fclose(file1);
    }
 
clock_t t2 = clock();
printf("%f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    
    printf("Done! Press any key...");
    getchar();
    return 0;
}

/////////////////////////////////////////////////////////////////////////////////////////
//Существует 2 массива, содержащих названия файлов.Требуется сравнить содержимое файлов 
//между собой, и если оно совпадает,то вывести на экран имена этих файлов.
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <fstream>
#include <functional>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
/////////////////////////////////////////////////////////////////////////////////////////
typedef std::string             T_str;
typedef std::vector < T_str >   T_strings;
/////////////////////////////////////////////////////////////////////////////////////////
bool    files_are_equal
    (
        T_str   const   &   filename_A,
        T_str   const   &   filename_B
    )
{
    std::ifstream   file_A( filename_A );
    std::ifstream   file_B( filename_B );
 
    bool    bool_res    =   file_A  &&  file_B;
 
    if( bool_res )
    {
        std::ostringstream  sout_A;
        sout_A  <<  file_A.rdbuf();
 
        std::ostringstream  sout_B;
        sout_B  <<  file_B.rdbuf();
 
        bool_res    =   sout_A.str() == sout_B.str();
    }//if
 
    return  bool_res;
}
/////////////////////////////////////////////////////////////////////////////////////////
void    in_file_with_name_load_symbol_an_amount
    (
        T_str   const   &   filename,
        char                symb,
        unsigned            symb_count
    )
{
    std::ofstream( filename )   <<  T_str( symb_count, symb );
}
/////////////////////////////////////////////////////////////////////////////////////////
void    compare_arrays_of_files_and_print_names_of_equal
    (
        T_strings   const   &   A,
        T_strings   const   &   B
    )
{
    std::for_each
        (
            A.begin     (),
            A.end       (),
 
            [=]         ( T_str     const   &   filename_A )
            {
                std::for_each
                    (
                        B.begin     (),
                        B.end       (),
 
                        [=]         ( T_str     const   &   filename_B )
                        {
                            if  (
                                    files_are_equal
                                        (
                                            filename_A,
                                            filename_B
                                        )
                                )
                            {
                                std::cout   <<  "Файлы \""
                                            <<  filename_A
                                            <<  "\" и \""
                                            <<  filename_B
                                            <<  "\" равны."
                                            <<  std::endl;
                            }
                        }//lambda
                    );//for_each
            }//lambda
        );//for_each
}
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    std::locale::global(std::locale(""));
 
    const   T_str   filename_A  =   "a.txt";
    const   T_str   filename_B  =   "b.txt";
    const   T_str   filename_C  =   "c.txt";
 
    const   T_str   filename_D  =   "d.txt";
    const   T_str   filename_E  =   "e.txt";
    const   T_str   filename_F  =   "f.txt";
 
    int     symb_count  =   10000000;
 
    in_file_with_name_load_symbol_an_amount( filename_A,    'a',    symb_count );
    in_file_with_name_load_symbol_an_amount( filename_B,    'a',    symb_count );
 
    in_file_with_name_load_symbol_an_amount( filename_D,    'a',    symb_count );
    in_file_with_name_load_symbol_an_amount( filename_E,    'a',    symb_count );
 
    T_strings   ABC;
    ABC.push_back( filename_A );
    ABC.push_back( filename_B );
    ABC.push_back( filename_C );
 
    T_strings   DEF;
    DEF.push_back( filename_D );
    DEF.push_back( filename_E );
    DEF.push_back( filename_F );
 
    compare_arrays_of_files_and_print_names_of_equal( ABC, DEF );
    system("pause");
}

#include <Windows.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
#include <ctime>
 
int main()
{ 
    const int N = 3;
    const int M = 3;
    const char* name_f1[N] = {"file1.txt", "file1.txt", "file3.txt"};
    const char* name_f2[M] = {"file4.txt", "file5.txt", "file4.txt"};
    
clock_t t1 = clock();
    
    for (int i = 0; i < N; ++i)
    {
        HANDLE file1 = CreateFile(name_f1[i], GENERIC_READ, 0, NULL, 
                                  OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
        if (file1 == INVALID_HANDLE_VALUE)
        {
            printf("%s%i\n", "CreateFile() Error code = ", GetLastError());
            getchar();
            return 0;
        }
        
        unsigned long size_f1 = GetFileSize(file1, NULL);
        if (size_f1 == INVALID_FILE_SIZE)
        {
            printf("%s%i\n", "GetFileSize() Error code = ", GetLastError());
            CloseHandle(file1);
            getchar();
            return 0;
        }
            
        HANDLE Map_f1  = NULL;
        char *pvSrc_f1 = NULL;
        for (int j = 0; j < M; ++j)
        {
            HANDLE file2 = CreateFile(name_f2[j], GENERIC_READ, 0, NULL, 
                                      OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
            
            if (file2 == INVALID_HANDLE_VALUE)
            {
                printf("%s%i\n", "CreateFile()! Error code = ", GetLastError());
                getchar();
                return 0;
            }
        
            unsigned long size_f2 = GetFileSize(file2, NULL);
            if (size_f2 == INVALID_FILE_SIZE)
            {
                printf("%s%i\n", "GetFileSize()! Error code = ", GetLastError());
                CloseHandle(file2);
                getchar();
                return 0;
            }
 
            if (size_f1 != size_f2)
            {
                CloseHandle(file2);
                continue;
            }
 
            if (Map_f1 == NULL)
            {
                Map_f1 = CreateFileMapping(file1, NULL, PAGE_READONLY, 0, 0, NULL);
                if (Map_f1 == NULL)
                {
                    printf("%s%i\n", "CreateFileMapping()! Error code = ", GetLastError());
                    CloseHandle(file1);
                    getchar();
                    return 0;
                }
                
                pvSrc_f1 = (char*)MapViewOfFile(Map_f1, FILE_MAP_READ, 0, 0, size_f1);
                if (pvSrc_f1 == NULL)
                {
                    printf("%s%i\n", "MapViewOfFile()! Error code = ", GetLastError());
                    CloseHandle(file1);
                    CloseHandle(Map_f1);
                    getchar();
                    return 0;
                }
                CloseHandle(Map_f1);
            }
 
            HANDLE Map_f2 =  CreateFileMapping(file2, NULL, PAGE_READONLY, 0, 0, NULL);
            if (Map_f2 == NULL)
            {
                printf("%s%i\n", "CreateFileMapping()! Error code = ", GetLastError());
                CloseHandle(file2);
                getchar();
                return 0;
            }
            CloseHandle(file2);
            
            char* pvSrc_f2 = (char*)MapViewOfFile(Map_f2, FILE_MAP_READ, 0, 0, size_f2);
            if (pvSrc_f2 == NULL)
            {
                printf("%s%i\n", "MapViewOfFile()! Error code = ", GetLastError());
                CloseHandle(file2);
                CloseHandle(Map_f2);
                getchar();
                return 0;
            }
            CloseHandle(Map_f2);
            
            if (memcmp(pvSrc_f1, pvSrc_f2, size_f1) != 0)
            {
                UnmapViewOfFile(pvSrc_f2);
                continue;
            }
 
            printf("%s%s%s\n", name_f1[i], " equal ", name_f2[j]);
            
            UnmapViewOfFile(pvSrc_f2);
        } // for()
        CloseHandle(file1);
        
        if (pvSrc_f1 != NULL)
        UnmapViewOfFile(pvSrc_f1);
    } // for()
 
clock_t t2 = clock();
printf("%f\n", (t2 - t1 + .0) / CLOCKS_PER_SEC); // время отработки
    
    printf("Done! Press any key...");
    getchar();
    return 0;
}