[C] Aiuto salvataggio matrice su file

[anx721]

devi scrivere:

fwrite(&(salvataggio -> righe), sizeof(int), 1, fp)
fwrite(&(salvataggio -> colonne), sizeof(int), 1, fp)

[sky_451]

ah
scusa ma queste funzioni che operano sui file le sto cominciando ad usare adesso e sono ancora abbastanza impedito.

[anx721]

in pratica alla fread e alla fwrtite devi passare il puntatore alla zona di memoria in cui leggere o scrivere; se è un array passi direttamente l'array, che è un puntatore, se è un'altra variabile passi il puntatore alla variabile con &

[sky_451]

Risolti tutti i problemi ce n'è subito qualcun'altro:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define TRUE 1
#define FALSE 0

// Dichiarazione della struttura contenente le info per il salvataggio
struct Salvataggio
{
	char *giocatore1;
	char *giocatore2;
};

int salva_partita (char *giocatore1, char *giocatore2);
int carica_partita (struct Salvataggio *caricamento);

main()
{
	char *giocatore1="pippo", *giocatore2="topolino";
	struct Salvataggio *caricamento;

	salva_partita(giocatore1, giocatore2);
	
	// aggiorno le stringhe originali con due stringhe vuote
	strcpy(giocatore1, ""); strcpy(giocatore2, ""); 
	
	// alloco memoria per una struct Salvataggio
	caricamento = (struct Salvataggio *) malloc(sizeof(struct Salvataggio)); 

	carica_partita(caricamento);

	printf("\ngiocatore1: %s\n", caricamento->giocatore1);
	printf("\ngiocatore2: %s\n", caricamento->giocatore2);

	return 0;
}

int salva_partita (char *giocatore1, char *giocatore2)
{
	char *filename = "save.dat";
	FILE *fp;
	int vero=TRUE, falso=FALSE;
	unsigned int len_giocatore1, len_giocatore2;

	if((fp = fopen(filename, "wb")) == NULL)  // apro il file binario in scrittura
		return falso;    // se il file non si apre correttamente la funzione termina
	
	/* conto i caratteri che compongono la stringa giocatore1 compreso il carattere \0 */
	len_giocatore1 = (strlen(giocatore1) + 1);
	/* conto i caratteri che compongono la stringa giocatore2 compreso il carattere \0 */
	len_giocatore2 = (strlen(giocatore2) + 1); 
	
	// salvo la lunghezza della stringa compreso il carattere \0
	if(fwrite(&len_giocatore1, sizeof(unsigned int), 1, fp) != 1)  
	{
		fclose(fp);         // se la scrittura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}
	
	// salvo la lunghezza della stringa compreso il carattere \0
	if(fwrite(&len_giocatore2, sizeof(unsigned int), 1, fp) != 1)  
	{
		fclose(fp);         // se la scrittura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}

	if(fwrite(giocatore1, sizeof(char), len_giocatore1, fp) != len_giocatore1)  // salvo su file giocatore1
	{
		fclose(fp);         // se la scrittura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}

	if(fwrite(giocatore2, sizeof(char), len_giocatore2, fp) != len_giocatore2)  // salvo su file giocatore2
	{
		fclose(fp);         // se la scrittura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}

	fclose(fp); // chiudo il file
	return vero;
}

int carica_partita (struct Salvataggio *caricamento)
{
	char *filename = "save.dat";
	FILE *fp;
	int vero=TRUE, falso=FALSE;
	unsigned int len_giocatore1, len_giocatore2;

	if((fp = fopen(filename, "rb")) == NULL)  // apro il file binario in scrittura
		return falso;    // se il file non si apre correttamente la funzione termina
	
	// leggo la lunghezza della stringa compreso il carattere \0
	if(fread(&len_giocatore1, sizeof(unsigned int), 1, fp) != 1)  
	{
		fclose(fp);         // se la lettura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}
	
	// leggo la lunghezza della stringa compreso il carattere \0
	if(fread(&len_giocatore2, sizeof(unsigned int), 1, fp) != 1)  
	{
		fclose(fp);         // se la lettura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}

	caricamento->giocatore1 = (char *) malloc(len_giocatore1 * sizeof(char));
	caricamento->giocatore2 = (char *) malloc(len_giocatore2 * sizeof(char));

	if(fread(caricamento->giocatore1, sizeof(char), len_giocatore1, fp) != len_giocatore1) // leggo il nome del giocatore1
	{
		fclose(fp);         // se la lettura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}

	if(fread(caricamento->giocatore2, sizeof(char), len_giocatore2, fp) != len_giocatore2) // leggo il nome del giocatore2
	{
		fclose(fp);         // se la lettura non avviene correttamente
		return falso;       // chiudo il file e la funzione termina
	}
	
	fclose(fp);
	return vero;
}

In pratica ho provato a salvare queste due stringhe su file. Questo programma però va in crash. Sicuramente sbaglio qualcosa. Cosa???
Grazie.

p.s. queste due istruzioni creano il problema:
strcpy(giocatore1, ""); strcpy(giocatore2, "");
però per me è essenziale che tutto funzioni anche con queste.

[anx721]

se definisci

char *a = "ciao";

'a' è un puntatore ad un letterale stringa costante che non deve essere modificato; se vuoi una normale stringa che puo esere modificata devi dichiarare:

char a[] = "ciao";

In pratica hai una stringa costante solo se inizializzi il puntatore direttaemnte con "ciao"; se fai:

char *a = malloc(bla bla bla);

puoi modificare il contenuro di a.

Inoltre ricorda che se la stringa ha una lunghezza massima pari a 10, e hai un campo char * che deve contenere tale stringa, devi allocare meroria per 11 caratteri, cioè per 10 + 1 che è il carattere di fine stringa.

[sky_451]

Si, così mi va
Si del carattere \0 ne ho tenuto conto infatti come vedi ho contato la lunghezza delle due stringhe facendo strlen() + 1.

[sky_451]

Ops mi sono scordato di ringraziarti. Sei stato veramente gentile a spiegarmi tutte queste cose.
Ciao.