1

我有这个功能可以扫描我的文件并根据您选择查看的记录打印出预先指定的记录：

void addressBook::showRecord(int pickNum) {
  PEOPLE2 p;
  ifstream indata("vectortest.dat", ios::binary);
  if(!indata) {
    cout << "Error opening file for reading " << endl;
    exit(0);
  }
  indata.seekg(pickNum * sizeof(PEOPLE2));
  indata.read(reinterpret_cast <char*> (&p), sizeof(PEOPLE2));
  cout << p.fName2 << " " << p.lName2 << " " << p.Address2 << " " << endl;
}

因此，您只需将 showRecord 弹出到 main 中，然后选择要打印的名称。假设我想查看存储的第二个名称，我会输入

newBook->showRecord(1);

一切都很好，花花公子，而且效果很好，但是如果我想走得更远怎么办。因此，我创建了另一个函数，该函数可以使用 showRecord 打印出地址簿中已存储到我的文件中的所有姓名。我试过这个：

void addressBook::showAll() {
  ifstream indata("vectortest.dat", ios::binary);
  for(int i = 0; i < indata.end; i++) {
    showRecord(i);
  }
}

它有效，但它只打印出从以前的作业中硬编码到我的 PERSON 结构中的东西：

addressBook *newBook = addressBook::newbookInst(); 

PERSON me[] = {{"First" , "Last", "ADDRESS"}, {"John", "Doe", "1234"}}; 
                    newBook->addPerson(me[1]); 

                    newBook->addPerson(me[0]);

这很奇怪，因为当我进入文件本身时，我可以看到所有添加的名称。

那么我该如何使用它才能真正打印出文件中的所有内容，而不仅仅是永久存储的两个条目？

这是我的 addressbook.h 和 addressbook.cpp 代码，以防您需要更好地了解正在发生的事情......

\\addressbook.h////////

#ifndef _ADDRESSBOOK
#define _ADDRESSBOOK
#include <fstream>
#include <vector>
#include<string>
using std::string;
#include <iostream>
using namespace std;

using std::istream;
using std::ostream;
namespace CJ
{
const int MAXADDRESS =25;

struct PERSON
{
    string fName;
    string lName;
    string Address;
};
struct PEOPLE2
{
    char fName2[25];
    char lName2[25];
    char Address2[25];
};

class addressBook
{
private:

    vector<PERSON> people;

    int head;
    int tail;

public:

    addressBook();

    addressBook(const PERSON &p);
    addressBook(const PERSON p[], int size);
    addressBook(char *fName, char *lName, char *address);
    bool addPerson(const PERSON &p);
    bool sortcomp(const PERSON& p1, const PERSON& p2);
    bool getPerson(PERSON &p);
    bool findPerson(const string& lastName, PERSON& p);
    bool findPerson(const string& lastName, const string& firstName, PERSON& p);
    void bubbleSort(int *array,int length);
    void printBook();
    void sort();
    void waitKey();
    static addressBook *newbookInst();
    static addressBook *tempNew;
    static PERSON *p();
    static PERSON *temPerson;
    void showRecord(int pickNum);
    void writeRecord();
    void showAll();


    friend ostream &operator << (ostream &, addressBook &);
    addressBook operator =(const string& str);
    addressBook &operator +=(const PERSON &p); 
    addressBook operator [](int x); 

};
}
#endif

\\addressbook.cpp/////

#include <iostream>
#include <fstream>
#include <cstdlib>
#include <conio.h>
#include <string>
using std::string;
#include "addressBook.h"
#include "menu.h"
namespace CJ
{
addressBook::addressBook()
    : head(0), tail(-1)
{

}

addressBook::addressBook(const PERSON &p)
    : head(0), tail(-1)
{
    addPerson(p);
}

addressBook::addressBook(const PERSON p[], int size)
    : head(0), tail(-1)
{
    for(int i = 0; i < size; i++)
        addPerson(p[i]);

}

addressBook::addressBook(char *fName, char *lName, char *Address)
    : head(0), tail(-1)
{
    PERSON tmp;
    tmp.fName = fName;
    tmp.lName = lName;
    tmp.Address = Address;
    addPerson(tmp);
}

bool addressBook::addPerson(const PERSON &p)
{
    people.push_back(p);

    if(tail == -1)
        tail++;
    return true; 
}

bool addressBook::getPerson(PERSON &p)
{
    if(tail >=0)
    {
        if(tail >= people.size())
            tail = 0;
        p = people[tail];
        tail++;
        return true;
    }
    return false;
}
bool addressBook::findPerson(const string &lastName, PERSON &p)
{
    for(size_t i = 0; i < people.size(); i++)
    {
        if(people[i].lName == lastName)
        {
            PERSON *p = addressBook::p();
            *p = people[i];
            return true;
        }
    }
    return false;
}
bool addressBook::findPerson(const string &lastName, const string &firstName, PERSON &p)
{
    for(size_t i = 0; i < people.size(); i++)
    {
        if(people[i].lName == lastName && people[i].fName == firstName)
        {
            PERSON *p = addressBook::p();
            *p = people[i];
            return true;
        }
    }
    return false;
}


void addressBook::printBook()
{
    for(size_t i = 0; i < people.size(); i++)
    {       
        std::cout << people[i].fName << "\t" << people[i].lName << "\t" << people[i].Address << std::endl;
    }
}


bool addressBook::sortcomp(const PERSON& p1, const PERSON& p2)
{
    int result = (p1.lName.compare(p2.lName)) ;
    if ( result > 0 )
        return true ;
    if ( result < 0 )
        return false ;
    return (p1.fName.compare(p2.fName)) > 0 ;
}

void addressBook::sort() 
{
    bool didSwap ;
    do
    {
        didSwap = false ;

        for ( unsigned i=1; i<people.size(); ++i )
            if ( sortcomp(people[i-1], people[i]) )
            {
                std::swap(people[i-1], people[i]) ;
                didSwap = true ;
            }

    } while ( didSwap ) ;
}

addressBook &addressBook::operator +=(const PERSON &p)
{
    addPerson(p);
    return *this;
};

addressBook addressBook::operator [](int x)
{
    return people[x];
};

ostream &operator << (ostream &output, addressBook &ab)
{
    PERSON tmp;
    ab.getPerson(tmp);
    output << tmp.fName << " " << tmp.lName << " " << tmp.Address << endl;
    return output;
}

addressBook * addressBook::tempNew = NULL;
addressBook *addressBook::newbookInst()
{
    if(tempNew == NULL)
    {
        tempNew = new addressBook;
    }
    return tempNew;
}

PERSON * addressBook::temPerson = NULL;
PERSON *addressBook::p()
{
    if(temPerson == NULL)
    {
        temPerson = new PERSON;
    }
    return temPerson;
}
bool status;
char lName[50];
char fName[50];

void addressBook::writeRecord()
{

PEOPLE2 temp;
ofstream outFile("vectortest.dat", ios::app);
    if(!outFile)
    {
        cout << "Error opening file for writing " << endl;
        return;
    }

        for (vector<PERSON>::iterator iter = people.begin(), end = people.end(); iter != end; ++iter)
        {
        strncpy(temp.fName2, iter->fName.c_str(), 25);
        strncpy(temp.lName2, iter->lName.c_str(), 25);
        strncpy(temp.Address2, iter->Address.c_str(), 25);
        outFile.write(reinterpret_cast<const char *>(&temp), sizeof(PEOPLE2));
        }       
    outFile.close();
}


void addressBook::showRecord(int pickNum)
{
PEOPLE2 p;

ifstream indata("vectortest.dat", ios::binary);
    if(!indata)
    {
        cout << "Error opening file for reading " << endl;
        exit(0);
    }

    indata.seekg(pickNum * sizeof(PEOPLE2));
    indata.read(reinterpret_cast<char *>(&p), sizeof(PEOPLE2));
    cout << p.fName2 << " " << p.lName2 << " " << p.Address2 << " " << endl;

    indata.close();

}

void addressBook::showAll()
{
ifstream indata("vectortest.dat", ios::binary);

for(int i = 0; i  < indata.end; i ++)
{
    showRecord(i);
}

}



}
4

1 回答 1

0

我真的不太了解您计划如何使用您的地址簿类的上下文。但是我所做的是将你所拥有的基本结构重新加工成更惯用的 C++。这应该有望帮助指导您在本课程中的未来工作。您遇到问题的文件读取问题已修复。

#include <iostream>
#include <iterator>
#include <fstream>
#include <cstdlib>
#include <conio.h>
#include <string>
#include <vector>
#include <algorithm>

const int MAXADDRESS = 25;

struct PEOPLE2
{
    char fName2[25];
    char lName2[25];
    char Address2[25];
};

struct PERSON
{
    PERSON()
    {}
    PERSON(PEOPLE2 p) 
        : fName(p.fName2), lName(p.lName2), Address(p.Address2)
    {}
    PERSON(const std::string& first, const std::string& last, const std::string& add)
        : fName(first), lName(last), Address(add)
    {}
    std::string fName;
    std::string lName;
    std::string Address;
};
// required for std::sort
bool operator< (const PERSON &lhs, const PERSON &rhs)
{
    int result = (lhs.lName.compare(rhs.lName));
    if(result == 0)
        return lhs.fName < rhs.fName;
    return result < 0;
}
// required for os << people
std::ostream& operator<< (std::ostream& os, const PERSON& rhs)
{
    os << rhs.fName << " " << rhs.lName << " " << rhs.Address;
    return os;
}

class addressBook
{
private:
    std::vector<PERSON> people;

public:

    addressBook()
    { }

    addressBook(const PERSON &p)
    {
        addPerson(p);
    }

    template<typename IT>
    addressBook(IT begin, IT end)
    {
        std::copy(begin, end, std::back_inserter(people));
    }

    addressBook(char *fName, char *lName, char *address)
    {
        PERSON tmp;
        tmp.fName = fName;
        tmp.lName = lName;
        tmp.Address = address;
        addPerson(tmp);
    }

    addressBook(const std::string& fileName)
    {
        std::ifstream indata(fileName, std::ios::binary);

        PEOPLE2 p;
        while(true)
        {
            indata.read(reinterpret_cast<char*>(&p), sizeof(PEOPLE2));
            if(indata.fail())
                break;
            people.push_back(p);
        }
    }

    void addPerson(const PERSON &p)
    {
        people.push_back(p);
    }

    bool findPerson(const std::string& lastName, PERSON& p)
    {
        std::find_if(std::begin(people), std::end(people), [&](const PERSON& in)->bool
        {
            if(lastName == in.lName)
            {
                p = in;
                return true;
            }
            return false;
        });
    }

    bool findPerson(const std::string& lastName, const std::string& firstName, PERSON& p)
    {
        std::find_if(std::begin(people), std::end(people), [&](const PERSON& in)->bool
        {
            if(lastName == in.lName && firstName == in.fName)
            {
                p = in;
                return true;
            }
            return false;
        });
    }

    void printBook()
    {
        std::for_each(std::begin(people), std::end(people), [](const PERSON& p)
        {       
            std::cout << p.fName << "\t" << p.lName << "\t" << p.Address << std::endl;
        });
    }

    void sort()
    {
        std::sort(std::begin(people),std::end(people));
    }

    void waitKey();

    void showRecord(int pickNum)
    {
        std::cout << people[pickNum] << std::endl;
    }

    void writeRecord(const std::string& fileName)
    {

        PEOPLE2 temp;
        std::ofstream outFile(fileName, std::ios::app);
        if(!outFile)
        {
            std::cout << "Error opening file for writing " << std::endl;
            return;
        }

        for(auto iter = people.begin(), end = people.end(); iter != end; ++iter)
        {
            strncpy(temp.fName2, iter->fName.c_str(), 25);
            strncpy(temp.lName2, iter->lName.c_str(), 25);
            strncpy(temp.Address2, iter->Address.c_str(), 25);
            outFile.write(reinterpret_cast<const char *>(&temp), sizeof(PEOPLE2));
        }       
    }

    void showAll()
    {
        std::for_each(std::begin(people), std::end(people), [](const PERSON& in)
        {
                std::cout << in << std::endl;
        });
    }


    friend std::ostream &operator << (std::ostream &output, addressBook &ab)
    {
        std::for_each(std::begin(ab.people), std::end(ab.people), [&](const PERSON& in)
        {
            output << in << "\n";
        });
        return output;
    }

    addressBook &operator +=(const PERSON &p)
    {
        addPerson(p);
        return *this;
    };

    PERSON operator [](int x)
    {
        return people[x];
    };

};

std::string fileName = "c:\\temp\\test.rec";
int main()
{
    addressBook ab(fileName);
    ab.sort();
    ab.showAll();

    //addressBook ab;
    //ab.addPerson(PERSON("Mary", "Smith", "1 West Street"));
    //ab.addPerson(PERSON("Joe", "Brown", "2 East Street"));
    //ab.addPerson(PERSON("Harry", "Cooper", "3 South Street"));
    //ab.writeRecord(fileName);
}
于 2013-04-07T07:45:02.210 回答