Thread: alternate to an array???

A quick google search yeilds 1 million words as a max estimate for the number of words in the English language, including archaic and scientific words. But half of those are too technical and domain specific and remained unchronicled in oxford. Multiply that by about 10 for all the forms of a word. (I'm not sure about this figure). Then multiply that by about 5.1 for the average word length. Thats still only 510 million bytes. Not even a gig.

ok so i had a go to getting this to work, and in theory what i have should merge 2 sorted list and filter out the doubles.... but for some reason it isnt working and i cant find whats wrong... Please help...

Code:

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>

using namespace std;

int main(int argc, char *argv[])
{
    int comp = 0;
    string wordA, wordB;
    ifstream wordlistA, wordlistB;
    ofstream output;
    
    wordlistA.open (argv[1]);
    wordlistB.open (argv[2]);
    output.open (argv[3]);
    
    if (wordlistA.is_open()&&wordlistB.is_open())
    {
        for (int i=0;;i++)
        {
            if (!wordlistA.eof()&&comp==-1||comp==0) {
               getline (wordlistA, wordA);
               /* debug */ cout << "in - " << wordA << endl;
            } else {
               do {
                  getline (wordlistB, wordB);
                  output << wordB << "\n";
               }while (!wordlistB.eof());
               break;
            }
            if (!wordlistB.eof()&&comp==1||comp==0) {
               getline (wordlistB, wordB);
               /* debug */ cout << "in - " << wordB << endl;
            } else {
               do {
                  getline (wordlistA, wordA);
                  output << wordA << "\n";
               }while (!wordlistA.eof());
               break;
            }
            comp = wordA.compare (wordB);
            /* debug */ cout << "comp - " << comp << endl;
            switch (comp) {
                   case -1:
                        output << wordA << "\n";
                        /* debug */ cout << "out - " << wordA << endl;
                   break;
                   case 1:
                        output << wordB << "\n";
                        /* debug */ cout << "out - " << wordB << endl;
                   break;
            }

       }
    }
    return EXIT_SUCCESS;
}

edit:
also, the two text files i am using for testing are worda.txt and wordb.txt which is just the alphabet split up into 2 files.

Here is an example that assumes that you can sort each file in memory, but cannot merge them in memory. Instead of demonstrating with files, I have chosen to demonstrate with a generous helping of stringstreams.

Code:

#include <iostream>
#include <string>
#include <sstream>
#include <vector>
#include <algorithm>
#include <iterator>

void sortWordList(std::istream& word_list, std::ostream& sorted_word_list);

int main()
{
    std::stringstream files[5];
    files[0] << "a d e f i j k m r s t y z";
    files[1] << "b c g h l n o p q u v w x";
    sortWordList(files[0], files[2]);
    sortWordList(files[1], files[3]);

    std::set_union(
        std::istream_iterator<std::string>(files[2]),
        std::istream_iterator<std::string>(),
        std::istream_iterator<std::string>(files[3]),
        std::istream_iterator<std::string>(),
        std::ostream_iterator<std::string>(files[4], " "));

    std::cout << files[4].str() << std::endl;
}

void sortWordList(std::istream& word_list, std::ostream& sorted_word_list)
{
    // Read in the words into memory.
    std::vector<std::string> words;
    std::copy(
        std::istream_iterator<std::string>(word_list),
        std::istream_iterator<std::string>(),
        std::back_inserter(words));

    // Sort the list, remove duplicates and store to the output stream.
    std::sort(words.begin(), words.end());
    std::copy(words.begin(), std::unique(words.begin(), words.end()),
        std::ostream_iterator<std::string>(sorted_word_list, " "));
}

If you cannot sort each individual word list in place, then the solution is to move half of the word list into another file, then use the process outlined above, without using sortWordList() since std::set_union would suffice.

A caveat though: this is based on how I think std::set_union should behave with respect to stream iterators (i.e., it does not keep everything in memory), and I could be wrong.

but with your files array you are reading and writing to & from them... where from what i understand with ifstream & ofstream one writes to a file and the other reads a file...

You can use std::fstream to both read and write from a file. You could also use an ofstream to write to a file, then use an ifstream to the same file to read from the file. The latter may well be simpler.