Удаляется exe файл при попытке компиляции

#pragma once
#include <string>
 
using namespace std;
 
class book{
    private:
        string author;
        string title;
        string publisher;
        int year;
        int pages;
    public:
        book();
        book(string inauthor, string intitle, string inpublisher, int inyear, int inpages);
        book(const book& orig);
 
        ~book();
 
        void setauthor(string inauthor);
        void settitle(string intitle);
        void setpublisher(string inpublisher);
        void setyear(int inyear);
        void setpages(int inpages);
 
        string getauthor();
        string gettitle();
        string getpublisher();
        int getyear();
        int getpages();
 
        void show();
};

#include "book.h"
#include <iostream>
 
book::book(){
    author="";
    title="";
    publisher="";
    year=0;
    pages=0;
}
 
book::book(string inauthor, string intitle, string inpublisher, int inyear, int inpages){
    author=inauthor;
    title=intitle;
    publisher=inpublisher;
    year=inyear;
    pages=inpages;
}
 
book::book(const book& orig){
    author=orig.author;
    title=orig.title;
    publisher=orig.publisher;
    year=orig.year;
    pages=orig.pages;
}
 
book::~book(){
}
 
void book::setauthor(string inauthor){
    author=inauthor;
}
void book::settitle(string intitle){
    title=intitle;
}
void book::setpublisher(string inpublisher){
    publisher=inpublisher;
}
void book::setyear(int inyear){
    year=inyear;
}
void book::setpages(int inpages){
    pages=inpages;
}
 
string book::getauthor(){
    return author;
}
string book::gettitle(){
    return title;
}
string book::getpublisher(){
    return publisher;
}
int book::getyear(){
    return year;
}
int book::getpages(){
    return pages;
}
 
void book::show(){
    cout<<"Book's author: "<<author<<"\n"
    <<"Book's title: "<<title<<"\n"
    <<"Book's publisher: "<<publisher<<"\n"
    <<"Book's year of release: "<<year<<"\n"
    <<"Number of pages in the book: "<<pages<<"\n \n";
}

#include "book.h"
#include <iostream>
#include <vector>
 
void menu(){
    cout<<"    Choose an option \n"
    <<"1: Add new books to the list \n"
    <<"2: Get a list of books of the same author \n"
    <<"3: Get a list of books with less pages than a certain amount \n"
    <<"4: Get a list of books published after a certain year: \n"
    <<"5: Close the program \n \n";
}
 
book donation(int iter){
    string newauthor;
    string newtitle;
    string newpublisher;
    int newyear;
    int newpages;
 
    cout<<iter<<" Enter the book's author: ";
    cin>>newauthor;
    
    cout<<" Enter the book's title: ";
    cin>>newtitle;
 
    cout<<" Enter the book's publisher: ";
    cin>>newpublisher;
 
    cout<<" Enter the book's year of release: ";
    cin>>newyear;
 
    cout<<" Enter the book's number of pages: ";
    cin>>newpages;
 
    book newbook(newauthor, newtitle, newpublisher, newyear, newpages);
 
    return newbook;
}
 
 
int main(){
    int amount;
    string key="";
    string prefauthor;
    int prefpages;
    int prefyear;
    vector <book> library={};
    while (1){
        menu();
        cin>>key;
        if (key=="1"){
            cout<<"\n How many books do you want to add? \n";
            cin>>amount;
            for (int i=0; i<amount; i++){
                book addbook=donation(i+1);
                library.push_back(addbook);
                cout<<"\n";
            }
        }
        else if (key=="2"){
            cout<<"Whose books do you want to see: \n";
            cin>>prefauthor;
            cout<<"\n";
            for (int i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getauthor()==prefauthor){
                    library[i].show();
                }
            }
            system("pause");
        }
        else if (key=="3"){
            cout<<"How many pages are too many for you: \n";
            cin>>prefpages;
            cout<<"\n";
            for (int i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getpages()<=prefpages){
                    library[i].show();
                }
            }
            system("pause");
        }
        else if (key=="4"){
            cout<<"Whose books do you want to see: \n";
            cin>>prefyear;
            cout<<"\n";
            for (int i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getyear()>prefyear){
                    library[i].show();
                }
            }
            system("pause");
        }
        else if (key=="5"){
            break;
        }
        else{
            cout<<"kill yourself \n";
            system("pause");
        }
    }
}

#pragma once
class book{
private:
    string author;
    string title;
    string publisher;
    int year;
    int pages;
public:
    book();
    book(string inauthor, string intitle, string inpublisher, int inyear, int inpages);
    book(const book& orig);
    ~book(){}
    book& operator=(const book& orig);
 
    void show(ostream& os);
 
    string getauthor(){return author;}
    int getpages(){return pages;}
    int getyear(){return year;}
};
ostream& operator<<(ostream& os,book& orig);

#include <string>
#include <iostream>
using namespace std;
 
#include "book.h"
 
book::book(){
    author="";
    title="";
    publisher="";
    year=0;
    pages=0;
}
 
book::book(string inauthor, string intitle, string inpublisher, int inyear, int inpages){
    author=inauthor;
    title=intitle;
    publisher=inpublisher;
    year=inyear;
    pages=inpages;
}
 
book::book(const book& orig){
    author=orig.author;
    title=orig.title;
    publisher=orig.publisher;
    year=orig.year;
    pages=orig.pages;
}
book& book::operator=(const book& orig){
    author=orig.author;
    title=orig.title;
    publisher=orig.publisher;
    year=orig.year;
    pages=orig.pages;
    return *this;
}
void book::show(ostream& os){
    os<<"Book's author: "<<author<<"\n"
        <<"Book's title: "<<title<<"\n"
        <<"Book's publisher: "<<publisher<<"\n"
        <<"Book's year of release: "<<year<<"\n"
        <<"Number of pages in the book: "<<pages<<"\n \n";
}
ostream& operator<<(ostream& os,book& orig)
{
    orig.show(os);
    return os;
}

#include "book.h"
#include <iostream>
#include <string>
#include <vector>
 
void menu(){
    cout<<"    Choose an option \n"
        <<"1: Add new books to the list \n"
        <<"2: Get a list of books of the same author \n"
        <<"3: Get a list of books with less pages than a certain amount \n"
        <<"4: Get a list of books published after a certain year: \n"
        <<"5: Close the program \n \n";
}
 
int main(){
    vector<book> library;
    while (true)
    {
        menu();
        int key;
        cin>>key;
        cin.get(); //  !!!!!!!!!!!!! 
        switch(key)
        {
        case 1:
        {
            cout<<"\n How many books do you want to add? \n";
            int amount;
            cin>>amount;
            cin.get(); //  !!!!!!!!!!!!! 
            for (int i=0; i<amount; i++){
                string newauthor;
                string newtitle;
                string newpublisher;
                int newyear;
                int newpages;
 
                cout<<i<<" Enter the book's author: ";
                getline(cin,newauthor); //  !!!!!!!!!!!!! 
 
                cout<<" Enter the book's title: ";
                getline(cin,newtitle);
 
                cout<<" Enter the book's publisher: ";
                getline(cin,newpublisher);
 
                cout<<" Enter the book's year of release: ";
                cin>>newyear;
 
                cout<<" Enter the book's number of pages: ";
                cin>>newpages;
                cin.get(); //  !!!!!!!!!!!!! 
 
                book newbook(newauthor, newtitle, newpublisher, newyear, newpages);
                library.push_back(newbook);
                cout<<"\n";
            }
        }
        break;
        case 2:
        {
            cout<<"Which author's books should be shown?: \n";
            string prefauthor;
            getline(cin,prefauthor); //  !!!!!!!!!!!!! 
            cout<<"\n";
            for (size_t i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getauthor()==prefauthor){
                    cout<<library[i];
                }
            }
            system("pause");
        }
        break;
        case 3:
        {
            cout<<"Books with maximum number of pages should be shown?: \n";
            int prefpages;
            cin>>prefpages;cin.get();
            cout<<"\n";
            for (size_t i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getpages()<=prefpages){
                    cout<<library[i];
                }
            }
            system("pause");
        }
        break;
        case 4:
        {
            cout<<"Minimum year of publication for books should be shown?: \n";
            int prefyear;
            cin>>prefyear;cin.get();
            cout<<"\n";
            for (size_t i=0; i<library.size(); i++){
                cout<<"Book "<<i+1<<": \n";
                if (library[i].getyear()>prefyear){
                    cout<<library[i];
                }
            }
            system("pause");
        }
        break;
        case 5:
            return 0;
        default:
            cout<<"kill yourself \n";
            system("pause");
            break;
        }
    }
    return 1;
}

#ifndef BOOKS_HPP
#define BOOKS_HPP
 
#include <string>
 
class Books {
private:
    std::string author;
    std::string title;
    std::string publisher;
    int year;
    int pages;
 
public:
    // Default constructor
    Books();
 
    // Parameterized constructor
    Books(const std::string& author, const std::string& title,
          const std::string& publisher, int year, int pages);
 
    // Getters
    std::string getAuthor() const;
    std::string getTitle() const;
    std::string getPublisher() const;
    int getYear() const;
    int getPages() const;
 
    // Setters
    void setAuthor(const std::string& author);
    void setTitle(const std::string& title);
    void setPublisher(const std::string& publisher);
    void setYear(int year);
    void setPages(int pages);
};
 
#endif // BOOKS_HPP

#include "Books.hpp"
 
// Default constructor
Books::Books()
    : author(""), title(""), publisher(""), year(0), pages(0) {}
 
// Parameterized constructor
Books::Books(const std::string& author, const std::string& title,
             const std::string& publisher, int year, int pages)
    : author(author), title(title), publisher(publisher), year(year), pages(pages) {}
 
// Getters
std::string Books::getAuthor() const { return author; }
std::string Books::getTitle() const { return title; }
std::string Books::getPublisher() const { return publisher; }
int Books::getYear() const { return year; }
int Books::getPages() const { return pages; }
 
// Setters
void Books::setAuthor(const std::string& author) { this->author = author; }
void Books::setTitle(const std::string& title) { this->title = title; }
void Books::setPublisher(const std::string& publisher) { this->publisher = publisher; }
void Books::setYear(int year) { this->year = year; }
void Books::setPages(int pages) { this->pages = pages; }

#include <iostream>
#include <vector>
#include <set>
#include <map>
#include "Books.hpp"
#include "populate.hpp"
 
int main() {
    std::vector<Books> books;
    if (!loadBooksFromXML("books.xml", books)) {
        std::cerr << "Error loading books from XML." << std::endl;
        return 1;
    }
 
    // a) All authors
    std::set<std::string> authors;
    for (const auto& b : books) {
        authors.insert(b.getAuthor());
    }
 
    std::cout << "All authors:" << std::endl;
    for (const auto& author : authors) {
        std::cout << "- " << author << std::endl;
    }
    std::cout << std::endl;
 
    // b) All books
    std::cout << "All books:" << std::endl;
    for (const auto& b : books) {
        std::cout << "Title: " << b.getTitle()
                  << ", Author: " << b.getAuthor()
                  << ", Publisher: " << b.getPublisher()
                  << ", Year: " << b.getYear()
                  << ", Pages: " << b.getPages()
                  << std::endl;
    }
    std::cout << std::endl;
 
    // c) Books by authors
    std::map<std::string, std::vector<Books>> booksByAuthor;
    for (const auto& b : books) {
        booksByAuthor[b.getAuthor()].push_back(b);
    }
 
    std::cout << "Books by authors:" << std::endl;
    for (const auto& entry : booksByAuthor) {
        std::cout << "Author: " << entry.first << std::endl;
        for (const auto& b : entry.second) {
            std::cout << "  - " << b.getTitle() << std::endl;
        }
    }
 
    return 0;
}

#include "Books.hpp"
#include <vector>
#include <string>
#include <iostream>
#include <libxml/parser.h>
#include <libxml/tree.h>
 
// Function to trim whitespace
static std::string trim(const std::string& str) {
    const char* whitespace = " \t\n\r";
    size_t start = str.find_first_not_of(whitespace);
    size_t end = str.find_last_not_of(whitespace);
    if (start == std::string::npos || end == std::string::npos)
        return "";
    return str.substr(start, end - start + 1);
}
 
// Function to parse XML and populate books vector
bool loadBooksFromXML(const std::string& filename, std::vector<Books>& books) {
    xmlDocPtr doc = xmlReadFile(filename.c_str(), nullptr, 0);
    if (doc == nullptr) {
        std::cerr << "Failed to parse " << filename << std::endl;
        return false;
    }
 
    xmlNodePtr root = xmlDocGetRootElement(doc);
    if (root == nullptr) {
        std::cerr << "Empty XML document" << std::endl;
        xmlFreeDoc(doc);
        return false;
    }
 
    for (xmlNodePtr node = root->children; node != nullptr; node = node->next) {
        if (node->type == XML_ELEMENT_NODE && xmlStrEqual(node->name, BAD_CAST "book")) {
            std::string author, title, publisher;
            int year = 0, pages = 0;
 
            for (xmlNodePtr child = node->children; child != nullptr; child = child->next) {
                if (child->type == XML_ELEMENT_NODE) {
                    std::string content;
                    if (xmlChar* prop = xmlNodeGetContent(child)) {
                        content = (const char*)prop;
                        xmlFree(prop);
                    }
 
                    if (xmlStrEqual(child->name, BAD_CAST "author")) {
                        author = trim(content);
                    } else if (xmlStrEqual(child->name, BAD_CAST "title")) {
                        title = trim(content);
                    } else if (xmlStrEqual(child->name, BAD_CAST "publisher")) {
                        publisher = trim(content);
                    } else if (xmlStrEqual(child->name, BAD_CAST "year")) {
                        year = std::stoi(trim(content));
                    } else if (xmlStrEqual(child->name, BAD_CAST "pages")) {
                        pages = std::stoi(trim(content));
                    }
                }
            }
 
            books.emplace_back(author, title, publisher, year, pages);
        }
    }
 
    xmlFreeDoc(doc);
    return true;
}

#ifndef POPULATE_HPP
#define POPULATE_HPP
bool loadBooksFromXML(const std::string& filename, std::vector<Books>& books);
#endif