How should I read in strings from 2 separate text files and compare for matches?

Question

I have 2 text files with strings(a few hundred each file). The idea is to compare the contents of each, if a match is found, then that string is outputted to one file. If there is no match found, then the string is outputted to a different file. Essentially, input file 1 contains a master list of names and I am comparing that to input file 2. So we take name 1 on the master list and then compare that name to every name on the the other input file.

The main part I am stuck on is making an algorithm that will correctly traverse the files. I am also not sure if I am comparing the strings correctly, but this could be a result of other errors. I am new to c++ so I am not totally aware of all the rules of the language.

So there are 480 names on the master list and 303 names on the 2nd list, so there should be 303 names matching and 177 not matching, I made counters to ensure the numbers matched up. First I tried a simple while loop that would loop as long as input from the master file was being taken in, but I ran into a problem where I wasn't matching all of the files(makes sense), so I thought that maybe I needed something a little more complex so I tried reading all of the values from each input file to their own arrays and tried to compare the elements of the arrays. I read and successfully printed the arrays, but I ran into some other issues. Namely segmentation fault, which was apparently caused by sizeof(), both I am still trying to troubleshoot. I tried doing it like this:

//Had problems with making empty arrays
string arrMidasMaster[480];
string arrMidasMath[303];

for (int i = 0; i < sizeof(arrMidasMaster); ++i)
    {
        for (int j = 0; j < sizeof(arrMidasMath); ++j)
        {
            if (arrMidasMaster[i] == arrMidasMath[j]) //match
            {
                outData_Elig << arrMidasMaster[i] << endl;
                num_eligible ++; //counter
            }
            else                                      //No match
            {
                continue;
                //Where can I put these statements?
                //outData_Ineli << arrMidasMaster[i] << endl;
                //num_ineligible ++; //counter
            }
        }
    }

In the grand scheme of things this looks like it should be able to do what I need it to do, but there are still things that need to be done with it. Other than the segmentation fault, the if else statement needs work. This is beacause I need to use continue to keep going until a match is found, but what if a match is never found, then it looks like it'll just go back to the outer loop and test the next name, but I want it to execute the 2 statements as shown above. I hope this is enough to go off of.

Answer 1

Your example code has a lot of issues that it is really a long task to go through each of them. You need to read lines from your files and dynamically fill the text in vectors. Then you don't need to specify size of the arrays. Also, you should check how to work with loops in C++. But following is an example code for what you are trying. Go through the code and read comments to understand, and try it out according to your use case. First try out with a small example and then with your actual text files.

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>

void compareFiles(const std::string& fileA, const std::string& fileB, const std::string& matchFile, const std::string& nonMatchFile) 
{
    std::ifstream inputFile1(fileA);
    std::ifstream inputFile2(fileB);
    std::ofstream outputFileMatch(matchFile);
    std::ofstream outputFileNonMatch(nonMatchFile);

    std::vector<std::string> masterList;  // to save the master list
    std::string line;

    // Read contents of fileA into a vector assuming each line has the text you want to match
    while (std::getline(inputFile1, line)) // reading until end of file
    {
        masterList.push_back(line); // push into the vector
    }

    // Compare contents of fileB with text from fileA in vector masterList
    while (std::getline(inputFile2, line)) // reading until end of file
    {
        if (std::find(masterList.begin(), masterList.end(), line) != masterList.end()) // check if the text in fileB is present in the fileA vector
        {
            outputFileMatch << line << "\n"; // write if match found
        } 
        else 
        {
            outputFileNonMatch << line << "\n"; // write if match not found
        }
    }

}

EDIT: As rightly pointed out by @john in the comment, it is not required to close the files as they would go out of scope automatically. So removed that code.

Answer 2

Not sure If I understood your problem correctly. Here is code which reads files line by line.

If line in first file "in.txt" is present in a dictionary file "dic.txt", then line is written to "foundItmes.txt" otherwise it is written to "remainintItmes.txt".

#include <algorithm>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <iterator>
#include <string>
#include <unordered_set>

class LineHelper {
    std::string data;

public:
    friend std::istream& operator>>(std::istream& is, LineHelper& l);
    operator std::string() const { return data; }
};

std::istream& operator>>(std::istream& is, LineHelper& l)
{
    return std::getline(is, l.data);
}

using LineInputStreamIter = std::istream_iterator<LineHelper>;

std::unordered_set<std::string> loadDictionary(std::istream& in)
{
    return { LineInputStreamIter { in }, {} };
}

std::unordered_set<std::string> loadDictionary(const std::filesystem::path& p)
{
    std::ifstream f { p };
    return loadDictionary(f);
}

void partitionCopy(std::istream& in, std::unordered_set<std::string> dic, std::ostream& trueOut, std::ostream& falseOut)
{
    std::partition_copy(
        LineInputStreamIter { in }, {},
        std::ostream_iterator<std::string> { trueOut, "\n" },
        std::ostream_iterator<std::string> { falseOut, "\n" },
        [&dic](const auto& s) { return dic.count(s) != 0; });
}

void partitionCopy(const std::filesystem::path& in, const std::filesystem::path& dic, const std::filesystem::path& trueOut, const std::filesystem::path& falseOut)
{
    std::ifstream inF { in };
    std::ofstream trueOutF { trueOut };
    std::ofstream falseOutF { falseOut };
    partitionCopy(inF, loadDictionary(dic), trueOutF, falseOutF);
}

int main()
{
    partitionCopy("in.txt", "dic.txt", "foundItmes.txt", "remainintItmes.txt");
    return 0;
}

https://godbolt.org/z/73e4h46d3

Didn't test that properly, but should work properly.

Answer 3

I was able to find the correct answer to the problem with everyones help, thank you. The find() function is looking for whatever matches to string line in the range of vComp's 1st element to its last. This is important because if you compare the files in the reversed order, you will only find matches. This is because string line will only contain matching strings and will not contain the rest of the non-matching data. This is always true when comparing a select group to the whole.

//Variable Declaration
ifstream inData_Master, inData_Comp;
ofstream outData_Match, outData_NonMatch;
int num_Matches = 0, num_NonMatches = 0; // counter
vector<string> vComp; // saves the compare list
string line;

inData_Master.open("Input_File_Master.txt");
inData_Comp.open("Input_File_Comp.txt");
outData_Match.open("Output_File_Match.txt");
outData_NonMatch.open("Output_File_NonMatch.txt");

// Reads & saves contents of our Comp input file, which will be compared against the Master file, store in line
while (getline(inData_Comp,line)) 
{
    vComp.push_back(line); // Adds new element to the end of the Vector via line
}
// Reads the contents of the master file 
while (getline(inData_Master, line))
{
    if (find(vComp.begin(),vComp.end(),line) != vComp.end()) // if nonMatch, find = vComp.end()  
    {
        outData_Match << line << endl; // match found
        num_Matches++; // counts match
    }
    else
    {
        outData_NonMatch << line << endl; // match not found
        num_NonMatches++; // counts non match
    }
}
cout << "Matches: " << num_matches << endl;
cout << "NonMatches: " << num_NonMatches << endl;