Распечатка информации из файла с помощью цикла с помощью другой функции, предназначенной для поиска файла

Question

Распечатка информации из файла с помощью цикла с помощью другой функции, предназначенной для поиска файла

У меня есть эта функция, которая может сканировать мой файл и распечатывать предварительно назначенную запись, в соответствии с которой вы выбираете:

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);
}

}}

1

addressbook c++file-io printing

Решение

Другие решения

Других решений пока нет …

Источник

Accepted Answer

Я не очень хорошо знаю о контексте того, как вы планируете использовать класс адресной книги. Но что я сделал, так это переделал базовую структуру того, что у вас было, в немного более идиоматический 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);
}

0