c++ - Lagring i Binær fil - Udvikleren.dk - Programmering, webdesign og grafik

Tags: c++ html html5

Bruger #6483 @ 12.01.05 10:37

Hej alle sammen og godt nytår (hvis det altså ikke er for sent at sige det

)...
Jeg er gået igang med at lave et lille project som skal kunne gemme informationer omkring DVD film i en binær fil som hedder DVDdatabase.dat...
Jeg kan huske at jeg engang så en person som havde lavet en "preformated" fil hvor han havde lavet 1000 records...
Jeg prøver nu selv at lave noget ligende.. jeg har derfor lavet en function som hedder formatDatabase() som "skulle" gå ind og lave en fil med 1000 rene accounts, jeg har så derefter lavet en lille function som hedder newDVD som gerne skulle gå ind og ligge noget i den første account (altså account 0) ...
jeg prøver derefter på at udskrive account 0 bagefter men intet sker...
Her er alt hvad jeg har lavet indtil vidre
DVDLibary.cpp

Kode

#include <iostream>
using namespace std;

#include <iomanip>
#include <string>
using std::string;

#include <stdlib.h>

#include<fstream>
using std::ifstream;
using std::ofstream;
using std::fstream;

#include "DVD.h"


char FILE_NAME[]="DVDdatabase.dat";

main()
{
	cout << endl;
	cout << "Checking for database..." << endl;
	cout << endl;
	
	//open for reading and writing!
	fstream inOutDatabase(FILE_NAME, ios::in | ios::out);

	//exit if can't open:
	if (!inOutDatabase)
	{
		cout << "No database file has been found..." << endl;
		int choise = 0;
		
		do
		{
			cout << "----------------------------------------------------------------" << endl;
			cout << "  1 - Exit" << endl;
			cout << "  2 - Create new database file" << endl;
			cout << "Enter a choise, and press <Enter>: ";
			cin >> choise;
		} while (choise < 1 || choise > 2);

		switch(choise)
		{
		case 1:
			exit(0);
		case 2:
			// create a new file...
			DVD::formatDatabase();
			
			fstream testFile(FILE_NAME);
			if (!testFile)
			{
				cout << "----------------------------------------------------------------" << endl;
				cout << "Error creating file... The program will terminate now!" << endl;
				cout << "----------------------------------------------------------------" << endl;
				exit(1);
			}
			else
			{
				cout << "The database has been sucessfully created..." << endl;  
			} // end if (!inOutSchedule)
			testFile.close();
			break;
		} // end switch
	}//end if(!inOutSchedule)
	else
	{
		cout << "Database sucessfully found..." << endl;
	}
	

	/***********/
	/* creates a test account on position 0 */
	/***********/
	DVD::newDVD(inOutDatabase);

	// should print record 0
	DVD::printDVD(inOutDatabase);
	return 0;
}

DVD.h

Kode

#ifndef DVD_H
#define DVD_H

class DVD {

public:
	// default constructor...
	DVD::DVD(string = "",	// title
			 int=0,			// year
			 int=0,			// serial
			 string = "");	// page

	// accessor for title
	void setTitle(string);
	string getTitle() const;
	// accessor for year
	void setYear(int);
	int getYear() const;
	// accessor for serial
	void setSerial(int);
	int getSerial() const;
	// accessor for page
	void setPage(string);
	string getPage() const;

	static void formatDatabase();
	static void newDVD(fstream&);
	static void printDVD(fstream&);
private:
	string title;
	int year;
	int serial;
	string page;

};//end class definition

#endif

DVD.cpp

Kode

#include <iostream>
#include <string>
using namespace std;
using std::string;

#include<fstream>
using std::ifstream;
using std::ofstream;
using std::fstream;

#include <stdlib.h>
#include "DVD.h"

/*********************************************************************/
/* DEFAULT CONSTRUCTOR                                               */
/*  string title                                                     */
/*  int    year                                                      */
/*  int    serial                                                    */
/*  string page                                                      */
/*********************************************************************/
DVD::DVD(string theTitle, int theYear, int theSerial, string thePage)
{
	setTitle(theTitle);
	setYear(theYear);
	setSerial(theSerial);
	setPage(thePage);
}
/*********************************************************************/
/* setTitle                                                          */
/*********************************************************************/
void DVD::setTitle(string theTitle)
{
	// copy at the most 50 characters to title
	const char *titleValue = theTitle.data();
	
	int length = theTitle.length();
	if (length > 50)
	{
		length = 50;
	}
	title = theTitle.substr(0, length);
	
}
/*********************************************************************/
/* getTitle                                                          */
/*********************************************************************/
string DVD::getTitle() const
{
	return title;
}
/*********************************************************************/
/* setYear                                                           */
/*********************************************************************/
void DVD::setYear(int theYear)
{
	year = theYear;
}
/*********************************************************************/
/* getYear                                                           */
/*********************************************************************/
int DVD::getYear() const
{
	return year;
}
/*********************************************************************/
/* setSerial                                                         */
/*********************************************************************/
void DVD::setSerial(int theSerial)
{
	serial = theSerial;
}
/*********************************************************************/
/* getSerial                                                         */
/*********************************************************************/
int DVD::getSerial() const
{
	return serial;
}
/*********************************************************************/
/* setPage                                                           */
/*********************************************************************/
void DVD::setPage(string thePage)
{
	// copy at the most 5 characters to page
	const char *pageValue = thePage.data();
	
	int length = thePage.length();
	if (length > 5)
	{
		length = 5;
	}
	page = thePage.substr(0, length);
}
/*********************************************************************/
/* getPage                                                           */
/*********************************************************************/
string DVD::getPage() const
{
	return page;
}
/*********************************************************************/
/* formatDatabase                                                    */
/*********************************************************************/
void DVD::formatDatabase()
{
	system("cls"); // claers the screen...
	cout << endl;
	char choise;
	bool OK = false;
	do
	{	
		cout << "Are you sure that you want to format the current file? (Y/N): ";
		cin >> choise;
		if ((choise == 'Y') || (choise == 'y') || (choise == 'N') || (choise == 'n'))
			OK = true;
		else
			OK = false;

	} while (OK == false);

	if (choise == 'Y' || choise == 'y')
	{
		ofstream databaseFile("DVDdatabase.dat", ios::binary);
		DVD blank;
		for (int i = 0; i < 1000; i++)
		{
			databaseFile.write(reinterpret_cast<const char *> (&blank), sizeof(DVD));
		} // end for
		databaseFile.close(); // close the steam!
	}
	else
	{
		exit(0);
	}
}

void DVD::newDVD(fstream &toDatabase)
{
	toDatabase.seekg((0)*sizeof(DVD));
	DVD newDVD;
	cout << "reading record..." << endl;
	toDatabase.read(reinterpret_cast<char *>(&newDVD), sizeof(DVD));
	char title[50] = "";
	// create it, if it doesn't already exist
	cout << "---------------------" << endl;
	cout << "Enter title: ";
	cin >> title; 

	// populate account...
	newDVD.setTitle(title);

	cout << "Writing record..." << endl;
	toDatabase.write(reinterpret_cast<const char *> (&newDVD), sizeof(DVD));
}
void DVD::printDVD(fstream &fromDatabase)
{
	fromDatabase.seekg((0)*sizeof(DVD));
	DVD newDVD2;
	fromDatabase << newDVD2.getTitle().data() << endl;
}

Jeg kan ikke selv finde ud af hvor det går galt, måske der er noget vigtigt som jeg har glemt/misforsået omkring lagring af data i en binær fil...
Jeg håber at der er nogen som kan finde fejlen eller måske bare guide mig hen imor en mulig løsning...

På forhånd tak!

Smox

[Redigeret d. 12/01-05 10:38:04 af Simon Rasmussen]

5 svar postet i denne tråd vises herunder
0 indlæg har modtaget i alt 0 karma

Sorter efter stemmer Sorter efter dato

Bruger #6483 @ 12.01.05 10:39

hehe jeg kan se at dHTML'en har lavet nogle små smillies i min kode, håber ikke at det er læsligt påtråds af det

Bruger #4996 @ 12.01.05 23:00

196

1: Filen vil altid blive åbnet i main(), hvis den ikke eksisterede vil der blive lavet en tom fil (med mindre det ikke var muligt at oprette filen).

2: I DVD::newDVD starter du med at læse en record, men filen var tom så dette går ikke godt. Derfor er du nødt til at slette filens interne fejl flag (toDatabase.clear()

og spole tilbage til starten af den record du lige har læst (eller ville have læst) (toDatabase.seekg((0)*sizeof(DVD))

.

3: Din DVD klasse indeholder 2 std::string's, når du skriver med toDatabase.write() skriver du kun std::string'ens interne data struktur og ikke indholdet af strengen. Du kan heller ikke læse indholdet af en std::string med toDatabase.read(), du bliver nødt til at læse og skrive de enkelte elementer i klassen for sig selv.

4: Det er en dårlig idé at bruge >> med char []'s

Bruger #6483 @ 14.01.05 10:15

3: Din DVD klasse indeholder 2 std::string's, når du skriver med toDatabase.write() skriver du kun std::string'ens interne data struktur og ikke indholdet af strengen. Du kan heller ikke læse indholdet af en std::string med toDatabase.read(), du bliver nødt til at læse og skrive de enkelte elementer i klassen for sig selv.

Nu ser det ud til at jeg får lavet filen rigtigt for jeg kan nu gemme heltal (integers) i filen og nu finde dem frem igen ... du skrev så her sidste gang at jeg skulle være opmærksom på mine strings og det er lige præsis mit problem nu for de bliver nemlig ikke gemt rigtigt ...

Koden til hvor jeg ligger data i account 0

Kode

void DVD::newDVD(fstream &toDatabase)
{
	char theTitle[50] = "";
	int theYear = 0;
	int theSerial = 0;
	char thePage[5] = "";
	
	cout << "========================" << endl;
	cout << "Title: ";
	cin.get();
	cin.getline(theTitle, 50);
	cout << "Year: ";
	cin >> theYear;
	cout << "Serial: ";
	cin >> theSerial;
	cout << "Page: ";
	cin.get();
	cin.getline(thePage, 5);
	cout << "========================" << endl;

	DVD newRecord;

	newRecord.setTitle(theTitle);
	newRecord.setYear(theYear);
	newRecord.setSerial(theSerial);
	newRecord.setPage(thePage);
	int x = 1;
	toDatabase.seekp((x-1)*sizeof(DVD));
	toDatabase.write(reinterpret_cast<const char *>(&newRecord), sizeof(DVD));
}

Koden som viser dataen igen:

Kode

void DVD::printDVD(fstream &fromDatabase)
{
	DVD newRecord;

	int x = 1;
	fromDatabase.seekg((x-1)*sizeof(DVD));
	fromDatabase.read(reinterpret_cast<char *>(&newRecord), sizeof(DVD));
	outputLine(cout, newRecord);	
}
void DVD::outputLine(ostream &output, const DVD &record)
{
	output << record.getTitle() << endl;
	output << record.getYear() << endl;
	output << record.getSerial() << endl;
	output << record.getPage() << endl;
}

Hvis jeg kunne få dig til at beskrive hvordan jeg skal lagre/printe mine strings rigtigt ville det være til en MEGET stor hjælp!

På forhånd tak!

Smox

Bruger #4996 @ 14.01.05 22:03

196

Jeg ville gøre noget i stil med:

Først skrive:
std::string Str; // String to write
//Make sure that str is no longer than 255 bytes:
if(Str.size() > 255)
Str = Str.sub_str(0, 255);

// Write the string part
char Temp[256];
strcpy(temp, Str.c_str());
out.write(Temp, strlen(Temp) + 1); // Make sure to write a 0 byte at the end.

// pad with dummy, as we must write 256 bytes (could use seek)
char Dummy:
for(int i = strlen(Temp); i < 256; i++)
out.write(&Dummy, 1);

For at læse:
in.read(Temp, 256);
std::string DestStr = Temp;

Bruger #4996 @ 15.01.05 01:18

196

Jeg lavede lige et komplet eksempel:

Kode

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <fstream>

const int MaxStringSize = 256;

class DVD
{
public:
   DVD::DVD(std::string aTitle = "", int aYear = 0, int aSerial = 0, std::string aPage = "") :
      title(aTitle), year(aYear), serial(aSerial), page(aPage)
   {}

   bool Write(std::ofstream &aStream)
   {
      if(title.size() > MaxStringSize - 1)
        title = title.substr(0, MaxStringSize - 1);
      aStream.write(title.c_str(), title.size() + 1);
      char dummy = 0;
      std::string::size_type i;
      for(i = title.size(); i < MaxStringSize - 1; i++)
         aStream.write(&dummy, 1);
      aStream.write((char *)&year, sizeof(year));
      aStream.write((char *)&serial, sizeof(serial));
      if(page.size() > MaxStringSize - 1)
        page = page.substr(0, MaxStringSize - 1);
      aStream.write(page.c_str(), page.size() + 1);
      for(i = page.size(); i < MaxStringSize - 1; i++)
         aStream.write(&dummy, 1);
      return true;
   }

   bool Read(std::ifstream &aStream)
   {
      char Temp[MaxStringSize];
      aStream.read(Temp, MaxStringSize);
      title = Temp;
      aStream.read((char *)&year, sizeof(year));
      aStream.read((char *)&serial, sizeof(serial));
      aStream.read(Temp, MaxStringSize);
      page = Temp;
      return true;
   }

   friend std::ostream & operator << (std::ostream &os, DVD &aDvd);
private:
   std::string title;
   int year;
   int serial;
   std::string page;
};

std::ostream & operator << (std::ostream &os, DVD &aDvd)
{
   os << "Title:  " << aDvd.title << std::endl;
   os << "Year:   " << aDvd.year << std::endl;
   os << "Serial: " << aDvd.serial << std::endl;
   os << "Page:   " << aDvd.page << std::endl;
   return os;
}

int main()
{
   {  // Create and write two entries
      DVD dvd1("Peter", 12, 34, "Nielsen");
      DVD dvd2("Poul", 123, 555, "Thomsen");
      std::ofstream out("database.dat", std::ios::binary);
      dvd1.Write(out);
      dvd2.Write(out);
   }
   {  // Read them back, anr print them on screen
      DVD List[2];
      std::ifstream in("database.dat", std::ios::binary);
      List[0].Read(in);
      List[1].Read(in);
      std::cout << List[0];
      std::cout << List[1];
   }
   std::cin.get();
}

Lagring i Binær fil

Karma barometer (30 dage)

Modtaget

Givet

Favorit hos
Forum tråde
Artikler