Почему появляется ошибка С2064 (очень давно не писала на С++)

void FileSorter::sortString(bool (FileSorter::*needsToBeMoved)(string, string))
{
    for (int i = 1; i < realSize; i++) {
        string currentElement = stringContent[i];
        int j;
        for (j = i - 1; j > 0 && needsToBeMoved(currentElement, stringContent[j]); j--) // C2064
            stringContent[j] = stringContent[j - 1];
        stringContent[j] = currentElement;
    }
}

(this ->*needsToBeMoved)(currentElement, stringContent[j])

#include "FileSorter.h"
 
int main(int argsNumber, char *args[]) {
    FileSorter fileSorter(argsNumber, args);
    cout << "Constructor passed...\n";
    fileSorter.sortTheFile();
}

#pragma once
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
class FileSorter
{
public:
    FileSorter();
    FileSorter(int argsNumber, char *args[]);
    FileSorter(string inputFileName, string OutputFileName, string containsStrings, string ascending);
    void sortTheFile();
    ~FileSorter();
private:
    static const int maxSize = 100;
    int realSize;
    string inputFileName,
        outputFileName,
        containsStringsString,
        ascendingString,
        stringContent[maxSize];
    int intContent[maxSize];
    static const char
        ascending[],
        descending[],
        fileDoesNotExist[],
        noArguments[],
        wrongArgs[],
        wrongArgsNumber[];
 
    bool argsAreOk(string fileContent, string sortType);
    int calculateRealSize();
    bool aBiggerThanBInt(int a, int b);
    bool aLessThanBInt(int a, int b);
    bool aBiggerThanBString(string a, string b);
    bool aLessThanBString(string a, string b);
    bool readTheFile();
    void printContent();
    void sortTheContent();
    void sortNumeric(bool(FileSorter::*needsToBeMoved)(int, int));
    void sortString(bool(FileSorter::*needsToBeMoved)(string, string));
    bool contentIsNumeric();
    void convertToNumeric();
};

#include "FileSorter.h"
 
const char FileSorter::ascending[] = "-a";
const char FileSorter::descending[] = "-d";
const char FileSorter::fileDoesNotExist[] = "File doesn't exist!\n";
const char FileSorter::noArguments[] = "No parameters!\n";
const char FileSorter::wrongArgs[] = "Wrong arguments values!\n";
const char FileSorter::wrongArgsNumber[] = "Wrong arguments number!\n";
 
FileSorter::FileSorter()
{
    cout << noArguments;
    exit(0);
}
 
FileSorter::FileSorter(int argsNumber, char *args[])
{
    if (argsNumber != 5) {
        cout << wrongArgsNumber;
        exit(0);
    }
    else {
        *this = FileSorter(args[1], args[2], args[3], args[4]);
    }
}
 
FileSorter::FileSorter(string inputFileName, string outputFileName, string containsStrings, string ascending)
{
    this->inputFileName.append(inputFileName);
    this->outputFileName.append(outputFileName);
    this->containsStringsString.append(containsStrings);
    this->ascendingString.append(ascending);
}
 
FileSorter::~FileSorter()
{
}
 
 
void FileSorter::sortTheFile()
{
    if (!readTheFile()) {
        cout << fileDoesNotExist;
    }
    else {
        readTheFile();
        printContent();
        sortTheContent();
    }
}
 
bool FileSorter::argsAreOk(string fileContent, string sortType) {
    if (fileContent.compare("-s") != 0 && fileContent.compare("-i") != 0)
        return false;
    if (sortType.compare("-a") != 0 && sortType.compare("-d") != 0)
        return false;
    return true;
}
 
int FileSorter::calculateRealSize()
{
    for (int i = 0; i < maxSize; i++)
        if (stringContent[i].empty())
            return i;
    return maxSize;
}
 
bool FileSorter::aBiggerThanBInt(int a, int b)
{
    return (a > b);
}
 
bool FileSorter::aLessThanBInt(int a, int b)
{
    return (a < b);
}
 
bool FileSorter::aBiggerThanBString(string a, string b)
{
    return a.compare(b) > 0;
}
 
bool FileSorter::aLessThanBString(string a, string b)
{
    return a.compare(b) < 0;
}
 
bool FileSorter::readTheFile()
{
    cout << "We are in readTheFile function...\n";
    cout << "InputFileName: [" << inputFileName << "]\n";
    ifstream fin(inputFileName);
    if (!fin.is_open()) {
        return false;
    }
    else {
        for (int i = 0;
            i < maxSize
            && fin >> stringContent[i]
            && !fin.eof();
            i++);
        return true;
    }
}
 
void FileSorter::printContent()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++) {
        cout << stringContent[i] << endl;
    }
}
 
void FileSorter::sortTheContent()
{
    realSize = calculateRealSize();
    if (contentIsNumeric()) {
        convertToNumeric();
        if (ascendingString.compare(ascending) == 0)
            sortNumeric(&FileSorter::aBiggerThanBInt);
        else
            sortNumeric(&FileSorter::aLessThanBInt);
    }
    else
        if (ascendingString.compare(ascending) == 0)
            sortString(&FileSorter::aBiggerThanBString);
        else
            sortString(&FileSorter::aLessThanBString);
}
 
void FileSorter::sortNumeric(bool (FileSorter::*needsToBeMoved)(int, int))
{
    for (int i = 1; i < realSize; i++) {
        int currentElement = intContent[i];
        int j;
        for (j = i - 1; j > 0 && this->(*needsToBeMoved)(currentElement, intContent[j]); j--)
            intContent[j] = intContent[j - 1];
        intContent[j] = currentElement;
    }
}
 
void FileSorter::sortString(bool (FileSorter::*needsToBeMoved)(string, string))
{
    for (int i = 1; i < realSize; i++) {
        string currentElement = stringContent[i];
        int j;
        for (j = i - 1; j > 0 && needsToBeMoved(currentElement, stringContent[j]); j--)
            stringContent[j] = stringContent[j - 1];
        stringContent[j] = currentElement;
    }
}
 
bool FileSorter::contentIsNumeric()
{
    for (int i = 0; i < maxSize; i++)
        for (int j = 0; (size_t)j < stringContent[i].length(); j++)
            if (stringContent[i].at(j) < '0' || stringContent[i].at(j) > '9')
                return false;
    return true;
}
 
void FileSorter::convertToNumeric()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++)
        intContent[i] = atoi(stringContent[i].c_str());
}

#pragma once
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
class FileSorter
{
public:
    FileSorter();
    FileSorter(int argsNumber, char *args[]);
    FileSorter(string inputFileName, string OutputFileName, string containsStrings, string ascending);
    void sortTheFile();
    ~FileSorter();
private:
    static const int maxSize = 100;
    int realSize;
    string inputFileName,
        outputFileName,
        containsStringsString,
        ascendingString,
        stringContent[maxSize];
    int intContent[maxSize];
    static const char
        ascending[],
        descending[],
        strings[],
        ints[],
        fileDoesNotExist[],
        noArguments[],
        wrongArgs[],
        wrongArgsNumber[],
        contentIsNotNumeric[];
 
    bool argsAreOk(string fileContent, string sortType);
    int calculateRealSize();
    bool contentIsNumeric();
    bool contentShouldBeNumeric();
    bool aBiggerThanBInt(int a, int b);
    bool aLessThanBInt(int a, int b);
    bool aBiggerThanBString(string a, string b);
    bool aLessThanBString(string a, string b);
    bool readTheFile();
    void printContent();
    void printOutput();
 
    void sortTheContent();
 
    void sortNumeric(bool(FileSorter::*needsToBeMoved)(int, int));
    void sortString(bool(FileSorter::*needsToBeMoved)(string, string));
    void convertToNumeric();
};

#include "FileSorter.h"
 
const char FileSorter::ascending[] = "-a";
const char FileSorter::descending[] = "-d";
const char FileSorter::strings[] = "-s";
const char FileSorter::ints[] = "-i";
const char FileSorter::fileDoesNotExist[] = "File doesn't exist!\n";
const char FileSorter::noArguments[] = "No parameters!\n";
const char FileSorter::wrongArgs[] = "Wrong arguments values!\n";
const char FileSorter::wrongArgsNumber[] = "Wrong arguments number!\n";
const char FileSorter::contentIsNotNumeric[] = "Content is not numeric!\n";
 
FileSorter::FileSorter()
{
    cout << noArguments;
    exit(0);
}
 
FileSorter::FileSorter(int argsNumber, char *args[])
{
    if (argsNumber != 5) {
        cout << wrongArgsNumber;
        exit(0);
    }
    else {
        *this = FileSorter(args[1], args[2], args[3], args[4]);
    }
}
 
FileSorter::FileSorter(string inputFileName, string outputFileName, string containsStrings, string ascending)
{
    this->inputFileName.append(inputFileName);
    this->outputFileName.append(outputFileName);
    this->containsStringsString.append(containsStrings);
    this->ascendingString.append(ascending);
}
 
FileSorter::~FileSorter()
{
}
 
 
void FileSorter::sortTheFile()
{
    if (!readTheFile()) {
        cout << fileDoesNotExist;
    }
    else {
        readTheFile();
        printContent();
        sortTheContent();
    }
}
 
bool FileSorter::argsAreOk(string fileContent, string sortType) {
    if (fileContent.compare("-s") != 0 && fileContent.compare("-i") != 0)
        return false;
    if (sortType.compare("-a") != 0 && sortType.compare("-d") != 0)
        return false;
    return true;
}
 
int FileSorter::calculateRealSize()
{
    for (int i = 0; i < maxSize; i++)
        if (stringContent[i].empty())
            return i;
    return maxSize;
}
 
bool FileSorter::aBiggerThanBInt(int a, int b)
{
    return (a > b);
}
 
bool FileSorter::aLessThanBInt(int a, int b)
{
    return (a < b);
}
 
bool FileSorter::aBiggerThanBString(string a, string b)
{
    return a.compare(b) > 0;
}
 
bool FileSorter::aLessThanBString(string a, string b)
{
    return a.compare(b) < 0;
}
 
bool FileSorter::readTheFile()
{
    cout << "We are in readTheFile function...\n";
    cout << "InputFileName: [" << inputFileName << "]\n";
    ifstream fin(inputFileName);
    if (!fin.is_open()) {
        return false;
    }
    else {
        for (int i = 0;
            i < maxSize
            && fin >> stringContent[i]
            && !fin.eof();
            i++);
        return true;
    }
}
 
void FileSorter::printContent()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++) {
        cout << stringContent[i] << endl;
    }
}
 
void FileSorter::printOutput()
{
    ofstream fout(outputFileName);
    for (int i = 0; i < realSize; i++)
        if (contentShouldBeNumeric())
            cout << intContent[i] << endl;
        else
            cout << stringContent[i] << endl;
}
 
void FileSorter::sortTheContent()
{
    realSize = calculateRealSize();
    if (contentShouldBeNumeric()) {
        convertToNumeric();
        if (ascendingString.compare(ascending) == 0)
            sortNumeric(&FileSorter::aBiggerThanBInt);
        else
            sortNumeric(&FileSorter::aLessThanBInt);
    }
    else
        if (ascendingString.compare(ascending) == 0)
            sortString(&FileSorter::aBiggerThanBString);
        else
            sortString(&FileSorter::aLessThanBString);
}
 
void FileSorter::sortNumeric(bool (FileSorter::*needsToBeMoved)(int, int))
{
    for (int i = 1; i < realSize; i++) {
        int currentElement = intContent[i];
        int j;
        for (j = i - 1; j > 0 && this->*needsToBeMoved(currentElement, intContent[j]); j--)
            intContent[j] = intContent[j - 1];
        intContent[j] = currentElement;
    }
}
 
void FileSorter::sortString(bool (FileSorter::*needsToBeMoved)(string, string))
{
    for (int i = 1; i < realSize; i++) {
        string currentElement = stringContent[i];
        int j;
        for (j = i - 1; j > 0 && this->needsToBeMoved(currentElement, stringContent[j]); j--)
            stringContent[j] = stringContent[j - 1];
        stringContent[j] = currentElement;
    }
}
 
bool FileSorter::contentIsNumeric()
{
    for (int i = 0; i < maxSize; i++)
        for (int j = 0; (size_t)j < stringContent[i].length(); j++)
            if (stringContent[i].at(j) < '0' || stringContent[i].at(j) > '9')
                return false;
    return true;
}
 
bool FileSorter::contentShouldBeNumeric()
{
    return containsStringsString.compare(strings) != 0;
}
 
void FileSorter::convertToNumeric()
{
    if (!contentIsNumeric()) {
        cout << contentIsNotNumeric;
        exit(0);
    }
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++)
        intContent[i] = atoi(stringContent[i].c_str());
}

#include "FileSorter.h"
 
const char FileSorter::ascending[] = "-a";
const char FileSorter::descending[] = "-d";
const char FileSorter::strings[] = "-s";
const char FileSorter::ints[] = "-i";
const char FileSorter::fileDoesNotExist[] = "File doesn't exist!\n";
const char FileSorter::noArguments[] = "No parameters!\n";
const char FileSorter::wrongArgs[] = "Wrong arguments values!\n";
const char FileSorter::wrongArgsNumber[] = "Wrong arguments number!\n";
const char FileSorter::contentIsNotNumeric[] = "Content is not numeric!\n";
 
FileSorter::FileSorter()
{
    cout << noArguments;
    exit(0);
}
 
FileSorter::FileSorter(int argsNumber, char *args[])
{
    if (argsNumber != 5) {
        cout << wrongArgsNumber;
        exit(0);
    }
    else {
        *this = FileSorter(args[1], args[2], args[3], args[4]);
    }
}
 
FileSorter::FileSorter(string inputFileName, string outputFileName, string containsStrings, string ascending)
{
    this->inputFileName.append(inputFileName);
    this->outputFileName.append(outputFileName);
    this->containsStringsString.append(containsStrings);
    this->ascendingString.append(ascending);
}
 
FileSorter::~FileSorter()
{
}
 
 
void FileSorter::sortTheFile()
{
    if (!readTheFile()) {
        cout << fileDoesNotExist;
    }
    else {
        readTheFile();
        printContent();
        sortTheContent();
    }
}
 
bool FileSorter::argsAreOk(string fileContent, string sortType) {
    if (fileContent.compare("-s") != 0 && fileContent.compare("-i") != 0)
        return false;
    if (sortType.compare("-a") != 0 && sortType.compare("-d") != 0)
        return false;
    return true;
}
 
int FileSorter::calculateRealSize()
{
    for (int i = 0; i < maxSize; i++)
        if (stringContent[i].empty())
            return i;
    return maxSize;
}
 
bool FileSorter::aBiggerThanBInt(int a, int b)
{
    return (a > b);
}
 
bool FileSorter::aLessThanBInt(int a, int b)
{
    return (a < b);
}
 
bool FileSorter::aBiggerThanBString(string a, string b)
{
    return a.compare(b) > 0;
}
 
bool FileSorter::aLessThanBString(string a, string b)
{
    return a.compare(b) < 0;
}
 
bool FileSorter::readTheFile()
{
    cout << "We are in readTheFile function...\n";
    cout << "InputFileName: [" << inputFileName << "]\n";
    ifstream fin(inputFileName);
    if (!fin.is_open()) {
        return false;
    }
    else {
        for (int i = 0;
            i < maxSize
            && fin >> stringContent[i]
            && !fin.eof();
            i++);
        return true;
    }
}
 
void FileSorter::printContent()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++) {
        cout << stringContent[i] << endl;
    }
}
 
void FileSorter::printOutput()
{
    ofstream fout(outputFileName);
    for (int i = 0; i < realSize; i++)
        if (contentShouldBeNumeric())
            cout << intContent[i] << endl;
        else
            cout << stringContent[i] << endl;
}
 
void FileSorter::sortTheContent()
{
    realSize = calculateRealSize();
    if (contentShouldBeNumeric()) {
        convertToNumeric();
        if (ascendingString.compare(ascending) == 0)
            sortNumeric(&FileSorter::aBiggerThanBInt);
        else
            sortNumeric(&FileSorter::aLessThanBInt);
    }
    else
        if (ascendingString.compare(ascending) == 0)
            sortString(&FileSorter::aBiggerThanBString);
        else
            sortString(&FileSorter::aLessThanBString);
}
 
void FileSorter::sortNumeric(bool (FileSorter::*needsToBeMoved)(int, int))
{
    for (int i = 1; i < realSize; i++) {
        int currentElement = intContent[i];
        int j;
        for (j = i - 1; j > 0 && (this->*needsToBeMoved)(currentElement, intContent[j]); j--)
            intContent[j] = intContent[j - 1];
        intContent[j] = currentElement;
    }
}
 
void FileSorter::sortString(bool (FileSorter::*needsToBeMoved)(string, string))
{
    for (int i = 1; i < realSize; i++) {
        string currentElement = stringContent[i];
        int j;
        for (j = i - 1; j > 0 && (this->needsToBeMoved)(currentElement, stringContent[j]); j--)
            stringContent[j] = stringContent[j - 1];
        stringContent[j] = currentElement;
    }
}
 
bool FileSorter::contentIsNumeric()
{
    for (int i = 0; i < maxSize; i++)
        for (int j = 0; (size_t)j < stringContent[i].length(); j++)
            if (stringContent[i].at(j) < '0' || stringContent[i].at(j) > '9')
                return false;
    return true;
}
 
bool FileSorter::contentShouldBeNumeric()
{
    return containsStringsString.compare(strings) != 0;
}
 
void FileSorter::convertToNumeric()
{
    if (!contentIsNumeric()) {
        cout << contentIsNotNumeric;
        exit(0);
    }
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++)
        intContent[i] = atoi(stringContent[i].c_str());
}

class FileSorter
{
public:
    FileSorter();
    FileSorter(int argsNumber, char *args[]);
    FileSorter(string inputFileName, string OutputFileName, string containsStrings, string ascending);
    void sortTheFile();
    ~FileSorter();
private:
    static const int maxSize = 100;
    int realSize;
    string inputFileName,
        outputFileName,
        containsStringsString,
        ascendingString,
        stringContent[maxSize];
    int intContent[maxSize];
    static const char
        ascending[],
        descending[],
        fileDoesNotExist[],
        noArguments[],
        wrongArgs[],
        wrongArgsNumber[];
 
    bool argsAreOk(string fileContent, string sortType);
    int calculateRealSize();
    bool aBiggerThanBInt(int a, int b);
    bool aLessThanBInt(int a, int b);
    bool aBiggerThanBString(string a, string b);
    bool aLessThanBString(string a, string b);
    bool readTheFile();
    void printContent();
    void sortTheContent();
    void sortNumeric(bool(FileSorter::*needsToBeMoved)(int, int));
    void sortString(bool(FileSorter::*needsToBeMoved)(string, string));
    bool contentIsNumeric();
    void convertToNumeric();
};

#pragma once
#include <iostream>
#include <fstream>
#include <string>
 
using namespace std;
 
class FileSorter
{
public:
    FileSorter();
    FileSorter(int argsNumber, char *args[]);
    FileSorter(string inputFileName, string OutputFileName, string containsStrings, string ascending);
    void sortTheFile();
    ~FileSorter();
private:
    static const int maxSize = 100;
    int realSize;
    string inputFileName,
        outputFileName,
        containsStringsString,
        ascendingString,
        stringContent[maxSize];
    int intContent[maxSize];
    static const char
        ascending[],
        descending[],
        fileDoesNotExist[],
        noArguments[],
        wrongArgs[],
        wrongArgsNumber[];
 
    bool argsAreOk(string fileContent, string sortType);
    int calculateRealSize();
    bool aBiggerThanBInt(int a, int b);
    bool aLessThanBInt(int a, int b);
    bool aBiggerThanBString(string a, string b);
    bool aLessThanBString(string a, string b);
    bool readTheFile();
    void printContent();
    void sortTheContent();
    void sortNumeric(bool(FileSorter::*needsToBeMoved)(int, int));
    void sortString(bool(FileSorter::*needsToBeMoved)(string, string));
    bool contentIsNumeric();
    void convertToNumeric();
};
 
const char FileSorter::ascending[] = "-a";
const char FileSorter::descending[] = "-d";
const char FileSorter::fileDoesNotExist[] = "File doesn't exist!\n";
const char FileSorter::noArguments[] = "No parameters!\n";
const char FileSorter::wrongArgs[] = "Wrong arguments values!\n";
const char FileSorter::wrongArgsNumber[] = "Wrong arguments number!\n";
 
FileSorter::FileSorter()
{
    cout << noArguments;
    exit(0);
}
 
FileSorter::FileSorter(int argsNumber, char *args[])
{
    if (argsNumber != 5) {
        cout << wrongArgsNumber;
        exit(0);
    }
    else {
        *this = FileSorter(args[1], args[2], args[3], args[4]);
    }
}
 
FileSorter::FileSorter(string inputFileName, string outputFileName, string containsStrings, string ascending)
{
    this->inputFileName.append(inputFileName);
    this->outputFileName.append(outputFileName);
    this->containsStringsString.append(containsStrings);
    this->ascendingString.append(ascending);
}
 
FileSorter::~FileSorter()
{
}
 
 
void FileSorter::sortTheFile()
{
    if (!readTheFile()) {
        cout << fileDoesNotExist;
    }
    else {
        readTheFile();
        printContent();
        sortTheContent();
    }
}
 
bool FileSorter::argsAreOk(string fileContent, string sortType) {
    if (fileContent.compare("-s") != 0 && fileContent.compare("-i") != 0)
        return false;
    if (sortType.compare("-a") != 0 && sortType.compare("-d") != 0)
        return false;
    return true;
}
 
int FileSorter::calculateRealSize()
{
    for (int i = 0; i < maxSize; i++)
        if (stringContent[i].empty())
            return i;
    return maxSize;
}
 
bool FileSorter::aBiggerThanBInt(int a, int b)
{
    return (a > b);
}
 
bool FileSorter::aLessThanBInt(int a, int b)
{
    return (a < b);
}
 
bool FileSorter::aBiggerThanBString(string a, string b)
{
    return a.compare(b) > 0;
}
 
bool FileSorter::aLessThanBString(string a, string b)
{
    return a.compare(b) < 0;
}
 
bool FileSorter::readTheFile()
{
    cout << "We are in readTheFile function...\n";
    cout << "InputFileName: [" << inputFileName << "]\n";
    ifstream fin(inputFileName);
    if (!fin.is_open()) {
        return false;
    }
    else {
        for (int i = 0;
            i < maxSize
            && fin >> stringContent[i]
            && !fin.eof();
            i++);
        return true;
    }
}
 
void FileSorter::printContent()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++) {
        cout << stringContent[i] << endl;
    }
}
 
void FileSorter::sortTheContent()
{
    realSize = calculateRealSize();
    if (contentIsNumeric()) {
        convertToNumeric();
        if (ascendingString.compare(ascending) == 0)
            sortNumeric(&FileSorter::aBiggerThanBInt);
        else
            sortNumeric(&FileSorter::aLessThanBInt);
    }
    else
        if (ascendingString.compare(ascending) == 0)
            sortString(&FileSorter::aBiggerThanBString);
        else
            sortString(&FileSorter::aLessThanBString);
}
 
void FileSorter::sortNumeric(bool (FileSorter::*needsToBeMoved)(int, int))
{
    for (int i = 1; i < realSize; i++) {
        int currentElement = intContent[i];
        int j;
        for (j = i - 1; j > 0 && (this->*needsToBeMoved)(currentElement, intContent[j]); j--)
            intContent[j] = intContent[j - 1];
        intContent[j] = currentElement;
    }
}
 
void FileSorter::sortString(bool (FileSorter::*needsToBeMoved)(string, string))
{
    for (int i = 1; i < realSize; i++) {
        string currentElement = stringContent[i];
        int j;
        for (j = i - 1; j > 0 && (this ->*needsToBeMoved)(currentElement, stringContent[j]); j--)
            stringContent[j] = stringContent[j - 1];
        stringContent[j] = currentElement;
    }
}
 
bool FileSorter::contentIsNumeric()
{
    for (int i = 0; i < maxSize; i++)
        for (int j = 0; (size_t)j < stringContent[i].length(); j++)
            if (stringContent[i].at(j) < '0' || stringContent[i].at(j) > '9')
                return false;
    return true;
}
 
void FileSorter::convertToNumeric()
{
    for (int i = 0; i < maxSize && !stringContent[i].empty(); i++)
        intContent[i] = atoi(stringContent[i].c_str());
}
 
 
int main(int argsNumber, char *args[])
{  
    FileSorter fileSorter(argsNumber, args);
    cout << "Constructor passed...\n";
    fileSorter.sortTheFile();
 
    system("pause"); 
}