[Error] expected constructor, destructor, or type conversion before '(' token

#include <ctime>
#include <string>
#include <vector>
#include <fstream>
#include <sstream>
#include <iostream>
#include "record.hpp"
#include "string_functions.hpp"
 
setlocale("LC_CTYPE", "Russian")
 
std::vector<std::string> readLinesIntoArr(std::ifstream &file) {
        std::string line;
        std::vector<std::string> fileLines;
 
        while(std::getline(file, line)) {
                fileLines.push_back(line);
        }
 
        return fileLines;
}
 
std::vector<Record> getRecords(std::string fileName) {
        const std::string phraseTag = "<phrase>";
        const std::string respTag = "<response>";
        std::vector<Record> records;
        std::vector<std::string> rawFile; 
        std::vector<std::string> splitString; 
        std::string line;
        char delim = '>';
        std::ifstream file("records.txt");
        rawFile = readLinesIntoArr(file);
        Record *curRec;
 
 
        for(int i = 0;i < rawFile.size();i++) {
                line = rawFile[i];
                if(line.find(phraseTag) != std::string::npos) { 
                        Record tempRec;
                        splitString = split(line, delim);
                        tempRec.phrase = splitString[1];
                        trim(tempRec.phrase);
                        records.push_back(tempRec);
                        curRec = &records[records.size()-1];
                } else if (line.find(respTag) != std::string::npos) {
                        splitString = split(line, delim);
                        trim(splitString[1]);
                        curRec->responses.push_back(splitString[1]);
                }
        }
 
        return records;
}
 
std::string getResponse(std::string input, std::vector<Record> records) {
        std::string response;
        std::vector<std::string> words = split(input, ' ');
        int total = levenshtein_distance(input, records[0].phrase);
        int index = 0;
 
    
        for (int i = 1; i < records.size(); i++) {
                int tempTotal = levenshtein_distance(input, records[i].phrase);
                if(tempTotal <= total) {
                        total = tempTotal;
                        index = i;
                }
        }
 
        int randIndex = rand() % records[index].responses.size();
        response = records[index].responses[randIndex];
 
        return response;
}
 
 
int main() {
        std::string sInput = "";
        std::string sResponse = "";
        std::ifstream myFile("records.txt");
        std::vector<Record> records;
        records = getRecords("records.txt");
 
        while(1) {
                std::cout << ">";
                getline(std::cin, sInput);
                if (sInput == "q") break;
                sResponse = getResponse(sInput, records);
                std::cout << sResponse << std::endl;
        }
 
        return 0;
}

#include "string_functions.hpp"
 
setlocale(LC_ALL, "Russian");
 
std::vector<std::string> split(std::string strToSplit, char delimeter) {
        std::stringstream ss(strToSplit);
        std::string item;
        std::vector<std::string> splittedStrings;
 
        while (std::getline(ss, item, delimeter))
        {
                splittedStrings.push_back(item);
        }
        return splittedStrings;
}
 
size_t levenshtein_distance(const std::string &s1, const std::string &s2) {
        const size_t m(s1.size());
        const size_t n(s2.size());
        
        if( m==0 ) return n;
        if( n==0 ) return m;
        
        size_t *costs = new size_t[n + 1];
        
        for( size_t k=0; k<=n; k++ ) costs[k] = k;
        
        size_t i = 0;
        for ( std::string::const_iterator it1 = s1.begin(); it1 != s1.end(); ++it1, ++i ) {
                costs[0] = i+1;
                size_t corner = i;
                
                size_t j = 0;
                for ( std::string::const_iterator it2 = s2.begin(); it2 != s2.end(); ++it2, ++j )
                {
                        size_t upper = costs[j+1];
                        if( *it1 == *it2 )
                        {
                                costs[j+1] = corner;
                        } else {
                                size_t t(upper<corner?upper:corner);
                                costs[j+1] = (costs[j]<t?costs[j]:t)+1;
                        }
                
                        corner = upper;
                }
        }
 
        size_t result = costs[n];
        delete [] costs;
 
        return result;
}
 
void trimLeading(std::string& str) {
        if (str.empty()) {
                return;
        }
 
        while (str.find(" ") == 0) {
                str.erase(0, 1);
        }
}
 
void trimTrailing(std::string& str) {
        if (str.empty()) {
                return;
        }
 
        size_t len = str.size();
 
        while(str.rfind(" ") == --len) {
                str.erase(len, len + 1);
        }
}
 
void trim(std::string& str) {
        trimLeading(str);
        trimTrailing(str);
}

#include "record.hpp"
 
 
 
setlocale(LC_ALL, "Russian");
 
void Record::printRecord() {
        std::cout << "Phrase: " << phrase << std::endl;
        std::cout << "Responses: " << std::endl;
        for (int i = 0; i < responses.size(); i++) {
                std::cout << '\t' << responses.at(i) << std::endl;
        }
}