fwrite()

Nu har jag ett problem igen...

Nu har jag kommit till att jag skall kunna spara och ladda mitt spel och till detta behöver jag kunna spara och ladde två olika strukturer. jag har kommit en bit men jag får det inte riktigt att funka.

//Standard Headerfiler//

#include "stdafx.h"

#include <conio.h>
#include <cstdlib>
#include <stdio.h>
#include <time.h>
#include <windows.h>
#include <winbase.h>
#include <wincon.h>
#include <iostream>
#include <string>

using namespace std;

//Egna Headerfiler//

#include "cars.h"
#include "gameoption.h"
#include "race.h"

//Egna Funktioner//
void huvudmeny();
void buymeny();	
void sellmeny();	
void show();
void racemeny();
void race();
void make_carinfo();
void startnewgame();

void loadgame();
void savegame();
void fatalerror();

void partmeny();
void gamemeny();
void deletemeny();
void intro();

HANDLE hConsoleOutput;

CONSOLE_SCREEN_BUFFER_INFO csbi;

int main(int argc, char* argv[])
{
// Här anropas senare savegame() samt loadgame()
}

void loadgame()
{
	FILE* file;

	file = fopen("test", "wb");

	fread(&player_1.money, sizeof(int), 1, file);
	fread(&player_1.pl_carhp, sizeof(int), 2, file);
	fread(&player_1.pl_carprice, sizeof(int), 3, file);
	fread(&player_1.pl_cartopspeed, sizeof(int), 4, file);
	fread(&player_1.totmoney, sizeof(int), 5, file);
	fread(&player_1.pl_name, sizeof(string), 1, file);
	
	fclose(file);

	huvudmeny();
}

void savegame()
{
	FILE* file;
	

	file = fopen("test", "wb");

	fwrite(&player_1.money, sizeof(int),1, file);
	fwrite(&player_1.pl_carhp, sizeof(int),1,  file);
	fwrite(&player_1.pl_carprice, sizeof(int),1, file);
	fwrite(&player_1.pl_cartopspeed, sizeof(int),1, file);
	fwrite(&player_1.totmoney, sizeof(int),1, file);
	fwrite(&player_1.pl_name, sizeof(string), 1, file);

	fclose(file);
	
	huvudmeny();

}

Strukturen Player ligger i headerfilen cars.h:

[KOD]

struct Player
{

	
	bool started;
	bool owncar;
	bool active;
	int money;
	int totmoney;
	string pl_name;
	int pl_caryrmodel;
	int pl_carprice;
	int pl_carhp;
	int pl_cartopspeed;
};

Kan någon tipsa mig skulle jag bli glad.......

Tack på förhand...[KOD]

Måste ju vara smidigare att köra med <fstream> och då ifstream och ofstream... då behöver du bara loopa en ström när du läser in / skriver datan typ:

ifstream in("filnamn");
while(!in.eof())
    in >> var1 >> var2 >> var3;

Och motsvarande för ostream...

ofstream ut("filnamn");
while(_data_finns_)
    ut << var1 << var2 << var3 << endl;
ut.close();

Sen kan man lägga in lite flaggor i initieringen (konstruktoranropet) beroende på vad som ska göras (append, binary m.m..)

Jag frågade i en annan tråd, men fick inget svar - så jag frågar igen. Finns det inget sätt att serialisera objekt/strukturer på med C++? Serialisering är ju wünderbar, då slipper man tänka så mycket. ;)

Vad menar du?

När det gäller inläsningen ovan blir det serialiserat genom att var1 kan vara en int och var2 kan vara en char... e.t.c
Sen kan man lätt köra en basklass och ärva ostream metoder som då kan läsa in en fils data i valfri metod m.h.a dynamisk bindning. Med lite trixande kan detta ske automagiskt.

Var det nåt sånt du menade :q

Som sagt, då är man ju tvungen att tänka... ;)

I Java behöver en klass endast implementera klassen Serializable för att kunna skrivas till en fil. Sen läser man tillbaka den, castar och vips har man sin fin-fina klass där igen. Det går på ca 2 rader. Det var alltså något liknande jag undrade om C++ hade. Tydligen inte. ;)

Tydligen inte

Inte i språket som jag vet (inom STL isf)... , men jag vet inte allt ;)
Å andra sidan har Java via automatik dynamisk bindning, men i C++ som eg är en hybrid och inget äkta OOP språk måste man skapa denna bindning själv. Men det går :)

OT: Inkluderade header-filer

Winbase.h och Wincon.h behöver du inte inkludera. I manualen står det "Header: Declared in Wincon.h; include Windows.h." och det har du redan gjort.

stdio.h och time.h kan ersättas med cstdio och ctime. conio.h kan inte ersättas med cconio, eftersom conio.h inte är standard.

Har du flera källkodsfiler bör du ta bort alla inkluderingar och lägga dem i en egen header-fil. På det viset behöver du bara inkludera den filen i varje källkodsfil.

Använder du Visual C++ kan du använda stdafx.h för detta ändamål. Då behöver header-filerna bara tolkas en gång, s.k. prekompilerade header-filer. Detta snabbar upp kompileringen av programmet.