C.Primer.Plus(第六版)第17章 编程练习

//17_1
//main.cpp
#include <iostream>
using namespace std;

char temp;
int count = 0;
int main()
{
    cout<<"please enter some character:";
    cin>>temp;
    while(temp != '$')
    {
        count++;
        cin>>temp;
    }
    cout<<"the count value is: "<<count<<endl;
    return 0;
}

//17_2
//main.cpp
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <string>
using namespace std;
int main(int argc,char* argv[])
{
    if(argc != 2)
    {
        cout<<"parameter don't match,error!";
        exit(EXIT_FAILURE);
    }
    string str;
    ofstream fout(argv[1]);
    while(getline(cin,str))
        fout<<str<<endl;
    fout.close();
    return 0;
}

//17_3
//main.cpp
#include <iostream>
#include <string>
#include <fstream>
#include <cstdlib>

int main(int argc,char* argv[])
{
    using namespace std;
    if(argc != 3)
    {
        cout<<"parameter don't match,ERROR!"<<endl;
        exit(EXIT_FAILURE);
    }
    ifstream fin(argv[1]);
    ofstream fout(argv[2]);
    string str;
    while(getline(cin,str))
        fout<<str<<endl;
    fin.close();
    fout.close();
    return 0;
}

//17_4
#include <iostream>
#include <string>
#include <fstream>
#include <cstdlib>

int main(int argc,char* argv[])
{
    using namespace std;
    if(argc != 4)
    {
        cout<<"parameter don't match,ERROR!";
        exit(EXIT_FAILURE);
    }
    ifstream fin_one(argv[1]);
    ifstream fin_two(argv[2]);
    ofstream fout(argv[3]);
    string str1,str2;
    while(!fin_one.eof() && !fin_two.eof() && getline(fin_one,str1) &&getline(fin_two,str2))
        fout<<str1<<" "<<str2<<endl;
    while(getline(fin_one,str1))
        fout<<str1<<endl;
    while(getline(fin_two,str2))
        fout<<str2<<endl;
    fin_one.close();
    fin_two.close();
    fout.close();
    return 0;
}

//17_5
#include <iostream>
#include <string>
#include <fstream>
#include <cstdlib>
#include <list>
#include <algorithm>
using namespace std;
const int COUNT = 30;
int main(int argc,char* argv[])
{

    if(argc !=  4)
    {
        cout<<"parameter don't match!";
        exit(EXIT_FAILURE);
    }
    ifstream fin_one(argv[1]);
    ifstream fin_two(argv[2]);
    ofstream fout(argv[3]);
    string str;
    list<string> listmat;
    list<string> listpat;
    list<string> listmerge(COUNT);
    while(getline(fin_one,str))
        listmat.push_back(str);
    while(getline(fin_two,str))
        listpat.push_back(str);
    listmat.sort();
    cout<<"Mat:\n";
    for each(string var in listmat)
        cout<<"\t"<<var<<endl;
    cout<<"\n";
    listpat.sort();
    cout<<"Pat:\n";
    for each(string var in listpat)
        cout<<"\t"<<var<<endl;
    cout<<"\n";

    merge(listmat.begin(),listmat.end(),listpat.begin(),listpat.end(),listmerge.begin());
    listmerge.unique();
    cout<<"Merge:\n";
    for each(string var in listmerge)
        fout<<"\t"<<var<<endl;
    fin_one.close();
    fin_two.close();
    fout.close();
    return 0;
}

//17_6
//main.cpp
#include "emp.h"

const char *FileName = "1.txt";  

int main()  
{  
    std::ifstream fin;  

    do  
    {  
        fin.clear();  
        fin.open(FileName);  
        if (fin.is_open())  
        {  
            std::cout << "当前文件" << FileName << "内容: \n";  
            int count = 0;  
            std::string str;  
            while (std::getline(fin, str))  
            {  
                abstr_emp *ptr = NULL;  
                if (str == "1")  
                {  
                    std::string fname, lname, job;  
                    std::getline(fin, fname);  
                    std::getline(fin, lname);  
                    std::getline(fin, job);  

                    ptr = new employee(fname, lname, job);  
                    ptr->ShowAll();  
                }  
                else if (str == "2")  
                {  
                    std::string fname, lname, job, inchargeof;  
                    std::getline(fin, fname);  
                    std::getline(fin, lname);  
                    std::getline(fin, job);  
                    std::getline(fin, inchargeof);  

                    ptr = new manager(fname, lname, job, atoi(inchargeof.c_str()));  
                    ptr->ShowAll();  
                }  
                else if (str == "3")  
                {  
                    std::string fname, lname, job, reportsto;  
                    std::getline(fin, fname);  
                    std::getline(fin, lname);  
                    std::getline(fin, job);  
                    std::getline(fin, reportsto);  

                    ptr = new fink(fname, lname, job, reportsto);  
                    ptr->ShowAll();  
                }  
                else  
                {  
                    std::string fname, lname, job, inchargeof, reportsto;  
                    std::getline(fin, fname);  
                    std::getline(fin, lname);  
                    std::getline(fin, job);  
                    std::getline(fin, inchargeof);  
                    std::getline(fin, reportsto);  

                    ptr = new highfink(fname, lname, job, reportsto, atoi(inchargeof.c_str()));  
                    ptr->ShowAll();  
                }  
                std::getline(fin, str);  
            }  
            fin.close();  
        }  

        std::ofstream fout(FileName, std::ios::out | std::ios::app);  
        if (!fout.is_open())  
        {  
            std::cerr << "Can't open " << FileName << " file for output.\n";  
            exit(EXIT_FAILURE);  
        }  

        abstr_emp *ptr = NULL;  
        std::cout << "选择要生成的类型:\n";  
        std::cout << "1、employee\t2、manager\n3、fink\t4、highfink\n";  
        int ans;  
        std::cin >> ans;  
        std::cin.get();  
        switch (ans)  
        {  
        case 1:  
            ptr = new employee;  
            break;  
        case 2:  
            ptr = new manager;  
            break;  
        case 3:  
            ptr = new fink;  
            break;  
        case 4:  
            ptr = new highfink;  
            break;  
        default:  
            break;  
        }  
        ptr->SetAll();  
        ptr->WriteAll(fout);  

        char ch;  
        std::cout << "继续?<y/n>: ";  
        std::cin >> ch;  
        std::cin.get();  
        if (ch == 'n')  
            break;  
    } while (true);  

    fin.close();  
    return 0;  
}  

//emp.cpp  
#include "emp.h"  

abstr_emp::abstr_emp() : fname("NULL"), lname("NULL"), job("NULL")  
{  
}  

abstr_emp::abstr_emp(const std::string & fn, const std::string & ln, const std::string & j) : fname(fn), lname(ln), job(j)  
{  
}  

abstr_emp::abstr_emp(const abstr_emp & e) : fname(e.fname), lname(e.lname), job(e.job)  
{  
}  

void abstr_emp::ShowAll() const  
{  
    std::cout << "fname: " << GetFname() << std::endl;  
    std::cout << "lname: " << GetLname() << std::endl;  
    std::cout << "job: " << GetJob() << std::endl;  
}  

void abstr_emp::SetAll()  
{  
    SetFname();  
    SetLname();  
    SetJob();  
}  
void abstr_emp::WriteAll(std::ofstream & of)
{
    of<<GetFname()<<std::endl<<GetLname()<<std::endl<<GetJob()<<std::endl<<std::endl;
}  
std::ostream &operator<<(std::ostream &os, const abstr_emp &e)  
{  
    os << e.fname << ", " << e.lname << ", " << e.job;  
    return os;  
}  

abstr_emp::~abstr_emp()  
{  
}  

employee::employee() : abstr_emp()  
{  
}  

employee::employee(const std::string & fn, const std::string & ln, const std::string & j) : abstr_emp(fn, ln, j)  
{  
}  

void employee::ShowAll() const  
{  
    abstr_emp::ShowAll();  
}  

void employee::SetAll()  
{  
    abstr_emp::SetAll();  
}  

void employee::WriteAll(std::ofstream & of)
{
    of<<"1"<<std::endl;
    of<<GetFname()<<std::endl<<GetLname()<<std::endl<<GetJob()<<std::endl<<std::endl;
}  
manager::manager() : abstr_emp()  
{  
    inchargeof = 0;  
}  

manager::manager(const std::string & fn, const std::string & ln, const std::string & j, int ico) : abstr_emp(fn, ln, j)  
{  
    inchargeof = ico;  
}  

manager::manager(const abstr_emp & e, int ico) : abstr_emp(e)  
{  
    inchargeof = ico;  
}  

manager::manager(const manager & m) : abstr_emp((const abstr_emp &)m)  
{  
    inchargeof = m.inchargeof;  
}  

void manager::ShowAll() const  
{  
    abstr_emp::ShowAll();  
    std::cout << "inchargeof: " << InChargeOf() << std::endl;  
}  

void manager::SetAll()  
{  
    abstr_emp::SetAll();  
    SetInChargeOf();  
}  

void manager::WriteAll(std::ofstream & of)
{
    of<<"2"<<std::endl;
    of<<GetFname()<<std::endl<<GetLname()<<std::endl<<GetJob()<<std::endl<<inchargeof<<std::endl<<std::endl;
}  

fink::fink() : abstr_emp()  
{  
    reportsto = "NULL";  
}  

fink::fink(const std::string & fn, const std::string & ln, const std::string & j, const std::string & rpo) : abstr_emp(fn, ln, j)  
{  
    reportsto = rpo;  
}  

fink::fink(const abstr_emp & e, const std::string & rpo) : abstr_emp(e)  
{  
    reportsto = rpo;  
}  

fink::fink(const fink & e) : abstr_emp((const abstr_emp &)e)  
{  
    reportsto = e.reportsto;  
}  

void fink::ShowAll() const  
{  
    abstr_emp::ShowAll();  
    std::cout << "reportsto" << ReportsTo() <<  std::endl;  
}  

void fink::SetAll()  
{  
    abstr_emp::SetAll();  
    SetReportsto();  
}  

void fink::WriteAll(std::ofstream & of)
{
    of<<"3"<<std::endl;
    of<<GetFname()<<std::endl<<GetLname()<<std::endl<<GetJob()<<std::endl<<reportsto<<std::endl<<std::endl;
}  

highfink::highfink() : abstr_emp(), manager(), fink()  
{  
}  

highfink::highfink(const std::string & fn, const std::string & ln, const std::string & j, const std::string & rpo, int ico) : abstr_emp(fn, ln, j), manager(fn, ln, j, ico), fink(fn, ln, j, rpo)  
{  
}  

highfink::highfink(const abstr_emp & e, const std::string & rpo, int ico) : abstr_emp(e), manager(e, ico), fink(e, rpo)  
{  
}  

highfink::highfink(const fink & f, int ico) : abstr_emp((const abstr_emp &)f), manager((const abstr_emp &)f, ico), fink(f)  
{  
}  

highfink::highfink(const manager & m, const std::string & rpo) : abstr_emp((const abstr_emp &)m), manager(m), fink((const abstr_emp &)m, rpo)  
{  
}  

highfink::highfink(const highfink & h) : abstr_emp((const abstr_emp &)h), manager((const manager &)h), fink((const fink &)h)  
{  
}  

void highfink::ShowAll() const  
{  
    abstr_emp::ShowAll();  
    std::cout << "inchargeof: " << InChargeOf() << std::endl;  
    std::cout << "reportsto: " << ReportsTo() << std::endl;  
}  

void highfink::SetAll()  
{  
    abstr_emp::SetAll();  
    manager::SetInChargeOf();  
    fink::SetReportsto();  
}  

void highfink::WriteAll(std::ofstream & of)
{
    of<<"4"<<std::endl;
    of<<GetFname()<<std::endl<<GetLname()<<std::endl<<GetJob()<<std::endl<<InChargeOf()<<std::endl<<ReportsTo()<<std::endl<<std::endl;
}  

//emp.h  
#ifndef EMP_H_  
#define EMP_H_  

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

class abstr_emp  
{  
private:  
    std::string fname;  
    std::string lname;  
    std::string job;  
protected:  
    const std::string &GetFname() const{ return fname; }  
    const std::string &GetLname() const { return lname; }  
    const std::string &GetJob() const { return job; }  
    void SetFname() { std::cout << "Input Fname: "; std::getline(std::cin, fname); }  
    void SetLname() { std::cout << "Input Lname: "; std::getline(std::cin, lname); }  
    void SetJob() { std::cout << "Input Job: "; std::getline(std::cin, job); }  
public:  
    abstr_emp();  
    abstr_emp(const std::string &fn, const std::string &ln, const std::string &j);  
    abstr_emp(const abstr_emp &e);  
    virtual void ShowAll() const;  
    virtual void SetAll(); 
    virtual void WriteAll(std::ofstream & of);
    friend std::ostream &operator<<(std::ostream &os, const abstr_emp &e);  
    virtual ~abstr_emp() = 0;  
};  

class employee : public abstr_emp  
{  
public:  
    employee();  
    employee(const std::string &fn, const std::string &ln, const std::string &j);  
    ~employee() {}  
    virtual void ShowAll() const;  
    virtual void SetAll();  
    virtual void WriteAll(std::ofstream & of);
};  

class manager : virtual public abstr_emp  
{  
private:  
    int inchargeof;  
protected:  
    int InChargeOf() const { return inchargeof; }  
    int &InChargOf() { return inchargeof; }  
    void SetInChargeOf() { std::cout << "Input InChargeOf: "; std::cin >> inchargeof; std::cin.get(); }  
public:  
    manager();  
    manager(const std::string &fn, const std::string &ln, const std::string &j, int ico = 0);  
    manager(const abstr_emp &e, int ico);  
    manager(const manager &m);  
    ~manager() {}  
    virtual void ShowAll() const;  
    virtual void SetAll();  
    virtual void WriteAll(std::ofstream & of);
};  

class fink : virtual public abstr_emp  
{  
private:  
    std::string reportsto;  
protected:  
    const std::string ReportsTo() const { return reportsto; }  
    std::string &ReportsTo() { return reportsto; }  
    void SetReportsto() { std::cout << "Input reportsto: "; std::getline(std::cin, reportsto); }  
public:  
    fink();  
    fink(const std::string &fn, const std::string &ln, const std::string &j, const std::string &rpo);  
    fink(const abstr_emp &e, const std::string &rpo);  
    fink(const fink &e);  
    ~fink() {}  
    virtual void ShowAll() const;  
    virtual void SetAll(); 
    virtual void WriteAll(std::ofstream & of);
};  

class highfink : public manager, public fink  
{  
public:  
    highfink();  
    highfink(const std::string &fn, const std::string &ln, const std::string &j, const std::string &rpo, int ico);  
    highfink(const abstr_emp &e, const std::string &rpo, int ico);  
    highfink(const fink &f, int ico);  
    highfink(const manager &m, const std::string &rpo);  
    highfink(const highfink &h);  
    ~highfink() {}  
    virtual void ShowAll() const;  
    virtual void SetAll();  
    virtual void WriteAll(std::ofstream & of);
};  

#endif  

//17_7
#include <iostream>  
#include <fstream>  
#include <string>  
#include <vector>  
#include <algorithm>  
#include <cstdlib>

void ShowStr(const std::string & str)
{
    std::cout<<str<<std::endl;
}
class Store
{
    std::ofstream & of;
public:
    Store(std::ofstream &out):of(out) {}
    void operator()(const std::string &str)
    {
         size_t len = str.size();           
        of.write((char*)&len, sizeof(std::size_t));    
        of.write(str.data(), len);     
    }
};

void GetStrs(std::ifstream &is, std::vector<std::string> &vec)  
{  
   size_t len;     
    while (is.read((char *)&len, sizeof(size_t)))  
    {   循环次数为目标文件中需恢复的数据长度
        char *st = new char[len];  
        is.read(st, len);   
        st[len + 1] = '\0';    
        vec.push_back(st);  
    }  
}  
//该程序以二进制打开文件，并使用read()和write()来完成I/O.
int main()  
{  
    using namespace std;  
    vector<string> vostr;  
    string temp;  

    cout << "Enter strings (empty line to quit):\n";  
    while (getline(cin, temp) && temp[0] != '\0')  
        vostr.push_back(temp);  
    cout << "Here is your input.\n";  
    for_each(vostr.begin(), vostr.end(), ShowStr);  

    ofstream fout("strings.txt", ios_base::out | ios_base::binary);  
    for_each(vostr.begin(), vostr.end(), Store(fout));  
    fout.close();  

    vector<string> vistr;  
    ifstream fin("strings.txt", ios_base::in | ios_base::binary);  
    if (!fin.is_open())  
    {  
        cerr << "Could not open file for input.\n";  
        exit(EXIT_FAILURE);  
    }  
    GetStrs(fin, vistr);  
    cout << "\nHere are the strings read form the file:\n";  
    for_each(vistr.begin(), vistr.end(), ShowStr);  

    return 0;  
}