#include <iostream>
#include <fstream>
#include <sstream>

/*
* Struct for managing data
*/
struct word_data {
std::string word;
unsigned occurrence;
};

int main(int argc, const char * argv[]) {
while(true) {
std::string filename;

/*
* Get dictionary filename from user.
*/
std::cout << "Enter filename: ";
std::cin >> filename;

/*
* File stream declaration.
* Attempt to open file that was
* specified by the user.
*/
std::ifstream file(filename);

/*
* Array that will store the words
* from our dictionary file.
*/
word_data* word_list = nullptr;

/*
* Make sure the file actually exists
* before continuing.
*/
if(file.is_open()) {
bool first_line = true;
int num_words = 0;
int list_size = 0;
unsigned counter = 0;
/*
* Success!
* Declare a string variable that
* will be used to store the current
* line of the file in iteration.
*/
std::string line;

/*
* Get contents of the file
*/
while(std::getline(file, line)) {
/*
* If first_line, get the specified
* number of words in the dictionary
* list.
*/
if(first_line) {
/*
* Convert string into integer
*/
std::istringstream buffer(line);
buffer >> num_words;

/*
* Exit if specified number of words is 0
*/
if(num_words == 0) {
std::cout << "Error, specified number of words is 0.\n";
return EXIT_FAILURE;
}

std::cout << "Dictionary list:\n\n";

/*
* Allocate space for words
*/
word_list = new word_data[ num_words ];
first_line = false;
continue;
}

/*
* Break out of loop and stop adding
* words if the words array is full.
*/
if(counter > num_words) {
break;
}

/*
* Declare word_data structure.
* Set the word and then occurrence
* to 0.
*/
word_data data;
data.word = line;
data.occurrence = 1;

std::cout << data.word << " : 0" << std::endl;

bool found = false;

/*
* Loop through list and check if
* word exists already. If it does,
* increment the occurrence.
*/
for(unsigned i = 0; i < counter; i++) {
if(line == word_list[ i ].word) {
word_list[ i ].occurrence++;
found = true;
break;
}
}

/*
* If the word doesn't exist in the
* the list, add it.
*/
if(found == false) {
word_list[ list_size ] = data;
list_size++;
}

counter++;
}

std::cout << "\nOccurrence of words in dictionary list:\n\n";

for(unsigned i = 0; i < list_size; i++) {
std::cout << word_list[ i ].word << " : " << word_list[ i ].occurrence << std::endl;
}
}
else {
/*
* Failed to open the file :(
*/
std::cout << "Error, failed to open file: " << filename << std::endl;
}

/*
* Close the file
*/
file.close();

/*
* Deallocate word_list array
*/
delete [ ] word_list;

/*
* Ask user if they want to exit
* or run the program again.
*/
char choice;

do {
std::cout << "Run program again? (Y / N): ";
std::cin >> choice;
} while(std::tolower(choice) != 'y' && std::tolower(choice) != 'n');

if(std::tolower(choice) == 'n') {
break;
}
}

return EXIT_SUCCESS;
}

Enter filename: dictionary
Dictionary list:

this : 0
this : 0
this : 0
is : 0
is : 0
a : 0
a : 0
a : 0
a : 0
dictionary : 0
list : 0

Occurrence of words in dictionary list:

this : 3
is : 2
a : 4
dictionary : 1
list : 1
Run program again? (Y / N):

11
this
this
this
is
is
a
a
a
a
dictionary
list

#include <iostream>
#include <fstream>
#include <sstream>

using namespace std;

struct Record
{
Record(){}
~Record(){}
string word;
int occurence;
};

//Dictionary
struct Dictionary
{
public:
Dictionary(int cap) : capacity(cap){ words = new Record[cap]; size = 0; }
~Dictionary() { delete words; }
void addWord(string);
void addOccurence(string);
void display();

private:
Record* words;
int size;
int capacity;
};

void Dictionary::addWord(string word)
{
this->words[this->size].word = word;
this->words[this->size].occurence = 0;
this->size++;
}

void Dictionary::addOccurence(string word)
{
for(int i = 0; i < this->size; i++)
if(this->words[i].word == word)
this->words[i].occurence++;
}

void Dictionary::display()
{
for(int i = 0; i < this->size; i++)
cout << this->words[i].word << " " << this->words[i].occurence << endl;
}
//End Dictionary


string readInputFileName();
void processFile(string);
Dictionary* readDictionaryFromFile(ifstream&);
void processDataFromFile(ifstream&, Dictionary*);
bool readUserChoice();


string readInputFileName()
{
string inputFileName;

cout << "Enter the input file name:" << endl;
cin >> inputFileName;

return inputFileName;
}

Dictionary* readDictionaryFromFile(ifstream& inputFile)
{
int numberOfWords;
Dictionary* dict;
string currentWord;

inputFile >> numberOfWords;

dict = new Dictionary(numberOfWords);

while(numberOfWords-- > 0)
{
inputFile >> currentWord;
dict->addWord(currentWord);
}

return dict;
}

void processDataFromFile(ifstream& inputFile, Dictionary* dict)
{
string line, word;

while(!inputFile.eof())
{
getline(inputFile,line);
istringstream iss(line);

while(iss >> word)
dict->addOccurence(word);

}
}

void processFile(string inputFileName)
{
Dictionary* dict;
ifstream inputFile;

//open file
inputFile.open(inputFileName.c_str(),ios::binary);

//create dictionary from file
dict = readDictionaryFromFile(inputFile);

//display dictionary with initial occurences
dict->display();

//read data from file and fill dictionary
processDataFromFile(inputFile,dict);

//close file
inputFile.close();

//display dictioanry with total occurences
dict->display();

//delete dictionary
delete dict;

}

bool readUserChoice()
{
char c;

cout << "Do you want to continue? (Y/y to continue. Any other key to quit)" << endl;
cin >> c;

return c == 'Y' || c == 'y';

}


int main()
{
bool choice;
string inputFileName;

do
{
inputFileName = readInputFileName();
processFile(inputFileName);
choice = readUserChoice();

}while(choice);

return 0;
}